query.pb.go

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

package types

import (
	context "context"
	fmt "fmt"
	types "github.com/cosmos/cosmos-sdk/codec/types"
	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
	types1 "github.com/cosmos/cosmos-sdk/types"
	query "github.com/cosmos/cosmos-sdk/types/query"
	_ "github.com/gogo/protobuf/gogoproto"
	grpc1 "github.com/gogo/protobuf/grpc"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
	_ "github.com/grpc-ecosystem/grpc-gateway/v2/protoc-gen-openapiv2/options"
	_ "github.com/regen-network/cosmos-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"
	_ "google.golang.org/protobuf/types/known/timestamppb"
	io "io"
	math "math"
	math_bits "math/bits"
	time "time"
)

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

// 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

// QueryParamsRequest is the request type for the Query/Params RPC method.
type QueryParamsRequest struct {
}

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

var xxx_messageInfo_QueryParamsRequest proto.InternalMessageInfo

// QueryParamsResponse is the response type for the Query/Params RPC method.
type QueryParamsResponse struct {
	Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
}

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

var xxx_messageInfo_QueryParamsResponse proto.InternalMessageInfo

func (m *QueryParamsResponse) GetParams() Params {
	if m != nil {
		return m.Params
	}
	return Params{}
}

// QueryPlansRequest is the request type for the Query/Plans RPC method.
type QueryPlansRequest struct {
	Type               string             `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
	FarmingPoolAddress string             `protobuf:"bytes,2,opt,name=farming_pool_address,json=farmingPoolAddress,proto3" json:"farming_pool_address,omitempty"`
	TerminationAddress string             `protobuf:"bytes,3,opt,name=termination_address,json=terminationAddress,proto3" json:"termination_address,omitempty"`
	StakingCoinDenom   string             `protobuf:"bytes,4,opt,name=staking_coin_denom,json=stakingCoinDenom,proto3" json:"staking_coin_denom,omitempty"`
	Terminated         string             `protobuf:"bytes,5,opt,name=terminated,proto3" json:"terminated,omitempty"`
	Pagination         *query.PageRequest `protobuf:"bytes,6,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryPlansRequest proto.InternalMessageInfo

func (m *QueryPlansRequest) GetType() string {
	if m != nil {
		return m.Type
	}
	return ""
}

func (m *QueryPlansRequest) GetFarmingPoolAddress() string {
	if m != nil {
		return m.FarmingPoolAddress
	}
	return ""
}

func (m *QueryPlansRequest) GetTerminationAddress() string {
	if m != nil {
		return m.TerminationAddress
	}
	return ""
}

func (m *QueryPlansRequest) GetStakingCoinDenom() string {
	if m != nil {
		return m.StakingCoinDenom
	}
	return ""
}

func (m *QueryPlansRequest) GetTerminated() string {
	if m != nil {
		return m.Terminated
	}
	return ""
}

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

// QueryPlansResponse is the response type for the Query/Plans RPC method.
type QueryPlansResponse struct {
	// plans are the existing plans
	Plans []*types.Any `protobuf:"bytes,1,rep,name=plans,proto3" json:"plans,omitempty"`
	// pagination defines the pagination in the response.
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryPlansResponse proto.InternalMessageInfo

func (m *QueryPlansResponse) GetPlans() []*types.Any {
	if m != nil {
		return m.Plans
	}
	return nil
}

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

// QueryPlanRequest is the request type for the Query/Plan RPC method.
type QueryPlanRequest struct {
	PlanId uint64 `protobuf:"varint,1,opt,name=plan_id,json=planId,proto3" json:"plan_id,omitempty"`
}

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

var xxx_messageInfo_QueryPlanRequest proto.InternalMessageInfo

func (m *QueryPlanRequest) GetPlanId() uint64 {
	if m != nil {
		return m.PlanId
	}
	return 0
}

// QueryPlanResponse is the response type for the Query/Plan RPC method.
type QueryPlanResponse struct {
	Plan *types.Any `protobuf:"bytes,1,opt,name=plan,proto3" json:"plan,omitempty"`
}

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

var xxx_messageInfo_QueryPlanResponse proto.InternalMessageInfo

func (m *QueryPlanResponse) GetPlan() *types.Any {
	if m != nil {
		return m.Plan
	}
	return nil
}

// QueryPositionRequest is the request type for the Query/Position RPC method.
type QueryPositionRequest struct {
	Farmer           string `protobuf:"bytes,1,opt,name=farmer,proto3" json:"farmer,omitempty"`
	StakingCoinDenom string `protobuf:"bytes,2,opt,name=staking_coin_denom,json=stakingCoinDenom,proto3" json:"staking_coin_denom,omitempty"`
}

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

var xxx_messageInfo_QueryPositionRequest proto.InternalMessageInfo

func (m *QueryPositionRequest) GetFarmer() string {
	if m != nil {
		return m.Farmer
	}
	return ""
}

func (m *QueryPositionRequest) GetStakingCoinDenom() string {
	if m != nil {
		return m.StakingCoinDenom
	}
	return ""
}

// QueryPositionResponse is the response type for the Query/Position RPC method.
type QueryPositionResponse struct {
	StakedCoins github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,1,rep,name=staked_coins,json=stakedCoins,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"staked_coins"`
	QueuedCoins github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,2,rep,name=queued_coins,json=queuedCoins,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"queued_coins"`
	Rewards     github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,3,rep,name=rewards,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"rewards"`
}

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

var xxx_messageInfo_QueryPositionResponse proto.InternalMessageInfo

func (m *QueryPositionResponse) GetStakedCoins() github_com_cosmos_cosmos_sdk_types.Coins {
	if m != nil {
		return m.StakedCoins
	}
	return nil
}

func (m *QueryPositionResponse) GetQueuedCoins() github_com_cosmos_cosmos_sdk_types.Coins {
	if m != nil {
		return m.QueuedCoins
	}
	return nil
}

func (m *QueryPositionResponse) GetRewards() github_com_cosmos_cosmos_sdk_types.Coins {
	if m != nil {
		return m.Rewards
	}
	return nil
}

// QueryStakingsRequest is the request type for the Query/Stakings RPC method.
type QueryStakingsRequest struct {
	Farmer           string             `protobuf:"bytes,1,opt,name=farmer,proto3" json:"farmer,omitempty"`
	StakingCoinDenom string             `protobuf:"bytes,2,opt,name=staking_coin_denom,json=stakingCoinDenom,proto3" json:"staking_coin_denom,omitempty"`
	Pagination       *query.PageRequest `protobuf:"bytes,3,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryStakingsRequest proto.InternalMessageInfo

func (m *QueryStakingsRequest) GetFarmer() string {
	if m != nil {
		return m.Farmer
	}
	return ""
}

func (m *QueryStakingsRequest) GetStakingCoinDenom() string {
	if m != nil {
		return m.StakingCoinDenom
	}
	return ""
}

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

// QueryStakingsResponse is the response type for the Query/Stakings RPC method.
type QueryStakingsResponse struct {
	Stakings   []StakingResponse   `protobuf:"bytes,1,rep,name=stakings,proto3" json:"stakings"`
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryStakingsResponse proto.InternalMessageInfo

func (m *QueryStakingsResponse) GetStakings() []StakingResponse {
	if m != nil {
		return m.Stakings
	}
	return nil
}

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

// QueryQueuedStakingsRequest is the request type for the Query/QueuedStakings RPC method.
type QueryQueuedStakingsRequest struct {
	Farmer           string             `protobuf:"bytes,1,opt,name=farmer,proto3" json:"farmer,omitempty"`
	StakingCoinDenom string             `protobuf:"bytes,2,opt,name=staking_coin_denom,json=stakingCoinDenom,proto3" json:"staking_coin_denom,omitempty"`
	Pagination       *query.PageRequest `protobuf:"bytes,3,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryQueuedStakingsRequest proto.InternalMessageInfo

func (m *QueryQueuedStakingsRequest) GetFarmer() string {
	if m != nil {
		return m.Farmer
	}
	return ""
}

func (m *QueryQueuedStakingsRequest) GetStakingCoinDenom() string {
	if m != nil {
		return m.StakingCoinDenom
	}
	return ""
}

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

// QueryQueuedStakingsResponse is the response type for the Query/QueuedStakings RPC method.
type QueryQueuedStakingsResponse struct {
	QueuedStakings []QueuedStakingResponse `protobuf:"bytes,1,rep,name=queued_stakings,json=queuedStakings,proto3" json:"queued_stakings"`
	Pagination     *query.PageResponse     `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryQueuedStakingsResponse proto.InternalMessageInfo

func (m *QueryQueuedStakingsResponse) GetQueuedStakings() []QueuedStakingResponse {
	if m != nil {
		return m.QueuedStakings
	}
	return nil
}

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

// QueryTotalStakingsRequest is the request type for the Query/TotalStakings RPC method.
type QueryTotalStakingsRequest struct {
	StakingCoinDenom string `protobuf:"bytes,1,opt,name=staking_coin_denom,json=stakingCoinDenom,proto3" json:"staking_coin_denom,omitempty"`
}

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

var xxx_messageInfo_QueryTotalStakingsRequest proto.InternalMessageInfo

func (m *QueryTotalStakingsRequest) GetStakingCoinDenom() string {
	if m != nil {
		return m.StakingCoinDenom
	}
	return ""
}

// QueryTotalStakingsResponse is the response type for the Query/TotalStakings RPC method.
type QueryTotalStakingsResponse struct {
	Amount github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,1,opt,name=amount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"amount"`
}

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

var xxx_messageInfo_QueryTotalStakingsResponse proto.InternalMessageInfo

// QueryRewardsRequest is the request type for the Query/Rewards RPC method.
type QueryRewardsRequest struct {
	Farmer           string             `protobuf:"bytes,1,opt,name=farmer,proto3" json:"farmer,omitempty"`
	StakingCoinDenom string             `protobuf:"bytes,2,opt,name=staking_coin_denom,json=stakingCoinDenom,proto3" json:"staking_coin_denom,omitempty"`
	Pagination       *query.PageRequest `protobuf:"bytes,3,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryRewardsRequest proto.InternalMessageInfo

func (m *QueryRewardsRequest) GetFarmer() string {
	if m != nil {
		return m.Farmer
	}
	return ""
}

func (m *QueryRewardsRequest) GetStakingCoinDenom() string {
	if m != nil {
		return m.StakingCoinDenom
	}
	return ""
}

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

// QueryRewardsResponse is the response type for the Query/Rewards RPC method.
type QueryRewardsResponse struct {
	Rewards    []RewardsResponse   `protobuf:"bytes,1,rep,name=rewards,proto3" json:"rewards"`
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryRewardsResponse proto.InternalMessageInfo

func (m *QueryRewardsResponse) GetRewards() []RewardsResponse {
	if m != nil {
		return m.Rewards
	}
	return nil
}

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

// QueryUnharvestedRewardsRequest is the request type for the Query/UnharvestedRewards RPC method.
type QueryUnharvestedRewardsRequest struct {
	Farmer           string             `protobuf:"bytes,1,opt,name=farmer,proto3" json:"farmer,omitempty"`
	StakingCoinDenom string             `protobuf:"bytes,2,opt,name=staking_coin_denom,json=stakingCoinDenom,proto3" json:"staking_coin_denom,omitempty"`
	Pagination       *query.PageRequest `protobuf:"bytes,3,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryUnharvestedRewardsRequest proto.InternalMessageInfo

func (m *QueryUnharvestedRewardsRequest) GetFarmer() string {
	if m != nil {
		return m.Farmer
	}
	return ""
}

func (m *QueryUnharvestedRewardsRequest) GetStakingCoinDenom() string {
	if m != nil {
		return m.StakingCoinDenom
	}
	return ""
}

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

// QueryUnharvestedRewardsResponse is the response type for the Query/UnharvestedRewards RPC method.
type QueryUnharvestedRewardsResponse struct {
	UnharvestedRewards []UnharvestedRewardsResponse `protobuf:"bytes,1,rep,name=unharvested_rewards,json=unharvestedRewards,proto3" json:"unharvested_rewards"`
	Pagination         *query.PageResponse          `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryUnharvestedRewardsResponse proto.InternalMessageInfo

func (m *QueryUnharvestedRewardsResponse) GetUnharvestedRewards() []UnharvestedRewardsResponse {
	if m != nil {
		return m.UnharvestedRewards
	}
	return nil
}

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

// QueryCurrentEpochDaysRequest is the request type for the Query/CurrentEpochDays RPC method.
type QueryCurrentEpochDaysRequest struct {
}

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

var xxx_messageInfo_QueryCurrentEpochDaysRequest proto.InternalMessageInfo

// QueryCurrentEpochDaysResponse is the response type for the Query/CurrentEpochDays RPC method.
type QueryCurrentEpochDaysResponse struct {
	CurrentEpochDays uint32 `protobuf:"varint,1,opt,name=current_epoch_days,json=currentEpochDays,proto3" json:"current_epoch_days,omitempty"`
}

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

var xxx_messageInfo_QueryCurrentEpochDaysResponse proto.InternalMessageInfo

func (m *QueryCurrentEpochDaysResponse) GetCurrentEpochDays() uint32 {
	if m != nil {
		return m.CurrentEpochDays
	}
	return 0
}

type StakingResponse struct {
	StakingCoinDenom string                                 `protobuf:"bytes,1,opt,name=staking_coin_denom,json=stakingCoinDenom,proto3" json:"staking_coin_denom,omitempty"`
	Amount           github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=amount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"amount"`
	StartingEpoch    uint64                                 `protobuf:"varint,3,opt,name=starting_epoch,json=startingEpoch,proto3" json:"starting_epoch,omitempty"`
}

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

var xxx_messageInfo_StakingResponse proto.InternalMessageInfo

func (m *StakingResponse) GetStakingCoinDenom() string {
	if m != nil {
		return m.StakingCoinDenom
	}
	return ""
}

func (m *StakingResponse) GetStartingEpoch() uint64 {
	if m != nil {
		return m.StartingEpoch
	}
	return 0
}

type QueuedStakingResponse struct {
	StakingCoinDenom string                                 `protobuf:"bytes,1,opt,name=staking_coin_denom,json=stakingCoinDenom,proto3" json:"staking_coin_denom,omitempty"`
	Amount           github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=amount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"amount"`
	EndTime          time.Time                              `protobuf:"bytes,3,opt,name=end_time,json=endTime,proto3,stdtime" json:"end_time"`
}

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

var xxx_messageInfo_QueuedStakingResponse proto.InternalMessageInfo

func (m *QueuedStakingResponse) GetStakingCoinDenom() string {
	if m != nil {
		return m.StakingCoinDenom
	}
	return ""
}

func (m *QueuedStakingResponse) GetEndTime() time.Time {
	if m != nil {
		return m.EndTime
	}
	return time.Time{}
}

type RewardsResponse struct {
	StakingCoinDenom string                                   `protobuf:"bytes,1,opt,name=staking_coin_denom,json=stakingCoinDenom,proto3" json:"staking_coin_denom,omitempty"`
	Rewards          github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,2,rep,name=rewards,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"rewards"`
}

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

var xxx_messageInfo_RewardsResponse proto.InternalMessageInfo

func (m *RewardsResponse) GetStakingCoinDenom() string {
	if m != nil {
		return m.StakingCoinDenom
	}
	return ""
}

func (m *RewardsResponse) GetRewards() github_com_cosmos_cosmos_sdk_types.Coins {
	if m != nil {
		return m.Rewards
	}
	return nil
}

type UnharvestedRewardsResponse struct {
	StakingCoinDenom string                                   `protobuf:"bytes,1,opt,name=staking_coin_denom,json=stakingCoinDenom,proto3" json:"staking_coin_denom,omitempty"`
	Rewards          github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,2,rep,name=rewards,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"rewards"`
}

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

var xxx_messageInfo_UnharvestedRewardsResponse proto.InternalMessageInfo

func (m *UnharvestedRewardsResponse) GetStakingCoinDenom() string {
	if m != nil {
		return m.StakingCoinDenom
	}
	return ""
}

func (m *UnharvestedRewardsResponse) GetRewards() github_com_cosmos_cosmos_sdk_types.Coins {
	if m != nil {
		return m.Rewards
	}
	return nil
}

func init() {
	proto.RegisterType((*QueryParamsRequest)(nil), "crescent.farming.v1beta1.QueryParamsRequest")
	proto.RegisterType((*QueryParamsResponse)(nil), "crescent.farming.v1beta1.QueryParamsResponse")
	proto.RegisterType((*QueryPlansRequest)(nil), "crescent.farming.v1beta1.QueryPlansRequest")
	proto.RegisterType((*QueryPlansResponse)(nil), "crescent.farming.v1beta1.QueryPlansResponse")
	proto.RegisterType((*QueryPlanRequest)(nil), "crescent.farming.v1beta1.QueryPlanRequest")
	proto.RegisterType((*QueryPlanResponse)(nil), "crescent.farming.v1beta1.QueryPlanResponse")
	proto.RegisterType((*QueryPositionRequest)(nil), "crescent.farming.v1beta1.QueryPositionRequest")
	proto.RegisterType((*QueryPositionResponse)(nil), "crescent.farming.v1beta1.QueryPositionResponse")
	proto.RegisterType((*QueryStakingsRequest)(nil), "crescent.farming.v1beta1.QueryStakingsRequest")
	proto.RegisterType((*QueryStakingsResponse)(nil), "crescent.farming.v1beta1.QueryStakingsResponse")
	proto.RegisterType((*QueryQueuedStakingsRequest)(nil), "crescent.farming.v1beta1.QueryQueuedStakingsRequest")
	proto.RegisterType((*QueryQueuedStakingsResponse)(nil), "crescent.farming.v1beta1.QueryQueuedStakingsResponse")
	proto.RegisterType((*QueryTotalStakingsRequest)(nil), "crescent.farming.v1beta1.QueryTotalStakingsRequest")
	proto.RegisterType((*QueryTotalStakingsResponse)(nil), "crescent.farming.v1beta1.QueryTotalStakingsResponse")
	proto.RegisterType((*QueryRewardsRequest)(nil), "crescent.farming.v1beta1.QueryRewardsRequest")
	proto.RegisterType((*QueryRewardsResponse)(nil), "crescent.farming.v1beta1.QueryRewardsResponse")
	proto.RegisterType((*QueryUnharvestedRewardsRequest)(nil), "crescent.farming.v1beta1.QueryUnharvestedRewardsRequest")
	proto.RegisterType((*QueryUnharvestedRewardsResponse)(nil), "crescent.farming.v1beta1.QueryUnharvestedRewardsResponse")
	proto.RegisterType((*QueryCurrentEpochDaysRequest)(nil), "crescent.farming.v1beta1.QueryCurrentEpochDaysRequest")
	proto.RegisterType((*QueryCurrentEpochDaysResponse)(nil), "crescent.farming.v1beta1.QueryCurrentEpochDaysResponse")
	proto.RegisterType((*StakingResponse)(nil), "crescent.farming.v1beta1.StakingResponse")
	proto.RegisterType((*QueuedStakingResponse)(nil), "crescent.farming.v1beta1.QueuedStakingResponse")
	proto.RegisterType((*RewardsResponse)(nil), "crescent.farming.v1beta1.RewardsResponse")
	proto.RegisterType((*UnharvestedRewardsResponse)(nil), "crescent.farming.v1beta1.UnharvestedRewardsResponse")
}

func init() {
	proto.RegisterFile("crescent/farming/v1beta1/query.proto", fileDescriptor_f2c82b2e0bfb203c)
}

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

// QueryClient is the client API for Query service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type QueryClient interface {
	// Params returns parameters of the farming module.
	Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error)
	// Plans returns all plans.
	Plans(ctx context.Context, in *QueryPlansRequest, opts ...grpc.CallOption) (*QueryPlansResponse, error)
	// Plan returns a specific plan.
	Plan(ctx context.Context, in *QueryPlanRequest, opts ...grpc.CallOption) (*QueryPlanResponse, error)
	Position(ctx context.Context, in *QueryPositionRequest, opts ...grpc.CallOption) (*QueryPositionResponse, error)
	// Stakings returns all stakings by a farmer.
	Stakings(ctx context.Context, in *QueryStakingsRequest, opts ...grpc.CallOption) (*QueryStakingsResponse, error)
	// QueryStakings returns all queued stakings by a farmer.
	QueuedStakings(ctx context.Context, in *QueryQueuedStakingsRequest, opts ...grpc.CallOption) (*QueryQueuedStakingsResponse, error)
	// TotalStakings returns total staking amount for a staking coin denom
	TotalStakings(ctx context.Context, in *QueryTotalStakingsRequest, opts ...grpc.CallOption) (*QueryTotalStakingsResponse, error)
	// Rewards returns rewards for a farmer
	Rewards(ctx context.Context, in *QueryRewardsRequest, opts ...grpc.CallOption) (*QueryRewardsResponse, error)
	// UnharvestedRewards returns unharvested rewards for a farmer
	UnharvestedRewards(ctx context.Context, in *QueryUnharvestedRewardsRequest, opts ...grpc.CallOption) (*QueryUnharvestedRewardsResponse, error)
	// CurrentEpochDays returns current epoch days.
	CurrentEpochDays(ctx context.Context, in *QueryCurrentEpochDaysRequest, opts ...grpc.CallOption) (*QueryCurrentEpochDaysResponse, error)
}

type queryClient struct {
	cc grpc1.ClientConn
}

func NewQueryClient(cc grpc1.ClientConn) QueryClient {
	return &queryClient{cc}
}

func (c *queryClient) Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) {
	out := new(QueryParamsResponse)
	err := c.cc.Invoke(ctx, "/crescent.farming.v1beta1.Query/Params", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) Plans(ctx context.Context, in *QueryPlansRequest, opts ...grpc.CallOption) (*QueryPlansResponse, error) {
	out := new(QueryPlansResponse)
	err := c.cc.Invoke(ctx, "/crescent.farming.v1beta1.Query/Plans", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) Plan(ctx context.Context, in *QueryPlanRequest, opts ...grpc.CallOption) (*QueryPlanResponse, error) {
	out := new(QueryPlanResponse)
	err := c.cc.Invoke(ctx, "/crescent.farming.v1beta1.Query/Plan", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) Position(ctx context.Context, in *QueryPositionRequest, opts ...grpc.CallOption) (*QueryPositionResponse, error) {
	out := new(QueryPositionResponse)
	err := c.cc.Invoke(ctx, "/crescent.farming.v1beta1.Query/Position", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) Stakings(ctx context.Context, in *QueryStakingsRequest, opts ...grpc.CallOption) (*QueryStakingsResponse, error) {
	out := new(QueryStakingsResponse)
	err := c.cc.Invoke(ctx, "/crescent.farming.v1beta1.Query/Stakings", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) QueuedStakings(ctx context.Context, in *QueryQueuedStakingsRequest, opts ...grpc.CallOption) (*QueryQueuedStakingsResponse, error) {
	out := new(QueryQueuedStakingsResponse)
	err := c.cc.Invoke(ctx, "/crescent.farming.v1beta1.Query/QueuedStakings", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) TotalStakings(ctx context.Context, in *QueryTotalStakingsRequest, opts ...grpc.CallOption) (*QueryTotalStakingsResponse, error) {
	out := new(QueryTotalStakingsResponse)
	err := c.cc.Invoke(ctx, "/crescent.farming.v1beta1.Query/TotalStakings", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) Rewards(ctx context.Context, in *QueryRewardsRequest, opts ...grpc.CallOption) (*QueryRewardsResponse, error) {
	out := new(QueryRewardsResponse)
	err := c.cc.Invoke(ctx, "/crescent.farming.v1beta1.Query/Rewards", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) UnharvestedRewards(ctx context.Context, in *QueryUnharvestedRewardsRequest, opts ...grpc.CallOption) (*QueryUnharvestedRewardsResponse, error) {
	out := new(QueryUnharvestedRewardsResponse)
	err := c.cc.Invoke(ctx, "/crescent.farming.v1beta1.Query/UnharvestedRewards", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) CurrentEpochDays(ctx context.Context, in *QueryCurrentEpochDaysRequest, opts ...grpc.CallOption) (*QueryCurrentEpochDaysResponse, error) {
	out := new(QueryCurrentEpochDaysResponse)
	err := c.cc.Invoke(ctx, "/crescent.farming.v1beta1.Query/CurrentEpochDays", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// QueryServer is the server API for Query service.
type QueryServer interface {
	// Params returns parameters of the farming module.
	Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error)
	// Plans returns all plans.
	Plans(context.Context, *QueryPlansRequest) (*QueryPlansResponse, error)
	// Plan returns a specific plan.
	Plan(context.Context, *QueryPlanRequest) (*QueryPlanResponse, error)
	Position(context.Context, *QueryPositionRequest) (*QueryPositionResponse, error)
	// Stakings returns all stakings by a farmer.
	Stakings(context.Context, *QueryStakingsRequest) (*QueryStakingsResponse, error)
	// QueryStakings returns all queued stakings by a farmer.
	QueuedStakings(context.Context, *QueryQueuedStakingsRequest) (*QueryQueuedStakingsResponse, error)
	// TotalStakings returns total staking amount for a staking coin denom
	TotalStakings(context.Context, *QueryTotalStakingsRequest) (*QueryTotalStakingsResponse, error)
	// Rewards returns rewards for a farmer
	Rewards(context.Context, *QueryRewardsRequest) (*QueryRewardsResponse, error)
	// UnharvestedRewards returns unharvested rewards for a farmer
	UnharvestedRewards(context.Context, *QueryUnharvestedRewardsRequest) (*QueryUnharvestedRewardsResponse, error)
	// CurrentEpochDays returns current epoch days.
	CurrentEpochDays(context.Context, *QueryCurrentEpochDaysRequest) (*QueryCurrentEpochDaysResponse, error)
}

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

func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Params not implemented")
}
func (*UnimplementedQueryServer) Plans(ctx context.Context, req *QueryPlansRequest) (*QueryPlansResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Plans not implemented")
}
func (*UnimplementedQueryServer) Plan(ctx context.Context, req *QueryPlanRequest) (*QueryPlanResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Plan not implemented")
}
func (*UnimplementedQueryServer) Position(ctx context.Context, req *QueryPositionRequest) (*QueryPositionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Position not implemented")
}
func (*UnimplementedQueryServer) Stakings(ctx context.Context, req *QueryStakingsRequest) (*QueryStakingsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Stakings not implemented")
}
func (*UnimplementedQueryServer) QueuedStakings(ctx context.Context, req *QueryQueuedStakingsRequest) (*QueryQueuedStakingsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueuedStakings not implemented")
}
func (*UnimplementedQueryServer) TotalStakings(ctx context.Context, req *QueryTotalStakingsRequest) (*QueryTotalStakingsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TotalStakings not implemented")
}
func (*UnimplementedQueryServer) Rewards(ctx context.Context, req *QueryRewardsRequest) (*QueryRewardsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Rewards not implemented")
}
func (*UnimplementedQueryServer) UnharvestedRewards(ctx context.Context, req *QueryUnharvestedRewardsRequest) (*QueryUnharvestedRewardsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UnharvestedRewards not implemented")
}
func (*UnimplementedQueryServer) CurrentEpochDays(ctx context.Context, req *QueryCurrentEpochDaysRequest) (*QueryCurrentEpochDaysResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CurrentEpochDays not implemented")
}

func RegisterQueryServer(s grpc1.Server, srv QueryServer) {
	s.RegisterService(&_Query_serviceDesc, srv)
}

func _Query_Params_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryParamsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Params(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/crescent.farming.v1beta1.Query/Params",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Params(ctx, req.(*QueryParamsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_Plans_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryPlansRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Plans(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/crescent.farming.v1beta1.Query/Plans",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Plans(ctx, req.(*QueryPlansRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_Plan_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryPlanRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Plan(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/crescent.farming.v1beta1.Query/Plan",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Plan(ctx, req.(*QueryPlanRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_Position_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryPositionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Position(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/crescent.farming.v1beta1.Query/Position",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Position(ctx, req.(*QueryPositionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_Stakings_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryStakingsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Stakings(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/crescent.farming.v1beta1.Query/Stakings",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Stakings(ctx, req.(*QueryStakingsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_QueuedStakings_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryQueuedStakingsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).QueuedStakings(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/crescent.farming.v1beta1.Query/QueuedStakings",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).QueuedStakings(ctx, req.(*QueryQueuedStakingsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_TotalStakings_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryTotalStakingsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).TotalStakings(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/crescent.farming.v1beta1.Query/TotalStakings",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).TotalStakings(ctx, req.(*QueryTotalStakingsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_Rewards_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryRewardsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Rewards(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/crescent.farming.v1beta1.Query/Rewards",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Rewards(ctx, req.(*QueryRewardsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_UnharvestedRewards_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryUnharvestedRewardsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).UnharvestedRewards(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/crescent.farming.v1beta1.Query/UnharvestedRewards",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).UnharvestedRewards(ctx, req.(*QueryUnharvestedRewardsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_CurrentEpochDays_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryCurrentEpochDaysRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).CurrentEpochDays(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/crescent.farming.v1beta1.Query/CurrentEpochDays",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).CurrentEpochDays(ctx, req.(*QueryCurrentEpochDaysRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Query_serviceDesc = grpc.ServiceDesc{
	ServiceName: "crescent.farming.v1beta1.Query",
	HandlerType: (*QueryServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Params",
			Handler:    _Query_Params_Handler,
		},
		{
			MethodName: "Plans",
			Handler:    _Query_Plans_Handler,
		},
		{
			MethodName: "Plan",
			Handler:    _Query_Plan_Handler,
		},
		{
			MethodName: "Position",
			Handler:    _Query_Position_Handler,
		},
		{
			MethodName: "Stakings",
			Handler:    _Query_Stakings_Handler,
		},
		{
			MethodName: "QueuedStakings",
			Handler:    _Query_QueuedStakings_Handler,
		},
		{
			MethodName: "TotalStakings",
			Handler:    _Query_TotalStakings_Handler,
		},
		{
			MethodName: "Rewards",
			Handler:    _Query_Rewards_Handler,
		},
		{
			MethodName: "UnharvestedRewards",
			Handler:    _Query_UnharvestedRewards_Handler,
		},
		{
			MethodName: "CurrentEpochDays",
			Handler:    _Query_CurrentEpochDays_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "crescent/farming/v1beta1/query.proto",
}

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

func (m *QueryParamsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

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

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

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

func (m *QueryPlansRequest) 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 = encodeVarintQuery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if len(m.Terminated) > 0 {
		i -= len(m.Terminated)
		copy(dAtA[i:], m.Terminated)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.Terminated)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.StakingCoinDenom) > 0 {
		i -= len(m.StakingCoinDenom)
		copy(dAtA[i:], m.StakingCoinDenom)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.StakingCoinDenom)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.TerminationAddress) > 0 {
		i -= len(m.TerminationAddress)
		copy(dAtA[i:], m.TerminationAddress)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.TerminationAddress)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.FarmingPoolAddress) > 0 {
		i -= len(m.FarmingPoolAddress)
		copy(dAtA[i:], m.FarmingPoolAddress)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.FarmingPoolAddress)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Type) > 0 {
		i -= len(m.Type)
		copy(dAtA[i:], m.Type)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.Type)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

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

func (m *QueryPositionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Rewards) > 0 {
		for iNdEx := len(m.Rewards) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Rewards[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQuery(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.QueuedCoins) > 0 {
		for iNdEx := len(m.QueuedCoins) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.QueuedCoins[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQuery(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.StakedCoins) > 0 {
		for iNdEx := len(m.StakedCoins) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.StakedCoins[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQuery(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *QueryStakingsRequest) 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 = encodeVarintQuery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.StakingCoinDenom) > 0 {
		i -= len(m.StakingCoinDenom)
		copy(dAtA[i:], m.StakingCoinDenom)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.StakingCoinDenom)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Farmer) > 0 {
		i -= len(m.Farmer)
		copy(dAtA[i:], m.Farmer)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.Farmer)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *QueryQueuedStakingsRequest) 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 = encodeVarintQuery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.StakingCoinDenom) > 0 {
		i -= len(m.StakingCoinDenom)
		copy(dAtA[i:], m.StakingCoinDenom)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.StakingCoinDenom)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Farmer) > 0 {
		i -= len(m.Farmer)
		copy(dAtA[i:], m.Farmer)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.Farmer)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

func (m *QueryRewardsRequest) 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 = encodeVarintQuery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.StakingCoinDenom) > 0 {
		i -= len(m.StakingCoinDenom)
		copy(dAtA[i:], m.StakingCoinDenom)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.StakingCoinDenom)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Farmer) > 0 {
		i -= len(m.Farmer)
		copy(dAtA[i:], m.Farmer)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.Farmer)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *QueryUnharvestedRewardsRequest) 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 = encodeVarintQuery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.StakingCoinDenom) > 0 {
		i -= len(m.StakingCoinDenom)
		copy(dAtA[i:], m.StakingCoinDenom)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.StakingCoinDenom)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Farmer) > 0 {
		i -= len(m.Farmer)
		copy(dAtA[i:], m.Farmer)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.Farmer)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *QueryCurrentEpochDaysRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

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

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

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

func (m *StakingResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.StartingEpoch != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.StartingEpoch))
		i--
		dAtA[i] = 0x18
	}
	{
		size := m.Amount.Size()
		i -= size
		if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintQuery(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.StakingCoinDenom) > 0 {
		i -= len(m.StakingCoinDenom)
		copy(dAtA[i:], m.StakingCoinDenom)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.StakingCoinDenom)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *QueuedStakingResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	n13, err13 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.EndTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.EndTime):])
	if err13 != nil {
		return 0, err13
	}
	i -= n13
	i = encodeVarintQuery(dAtA, i, uint64(n13))
	i--
	dAtA[i] = 0x1a
	{
		size := m.Amount.Size()
		i -= size
		if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintQuery(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.StakingCoinDenom) > 0 {
		i -= len(m.StakingCoinDenom)
		copy(dAtA[i:], m.StakingCoinDenom)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.StakingCoinDenom)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *QueryParamsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Params.Size()
	n += 1 + l + sovQuery(uint64(l))
	return n
}

func (m *QueryPlansRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Type)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.FarmingPoolAddress)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.TerminationAddress)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.StakingCoinDenom)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.Terminated)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if m.Pagination != nil {
		l = m.Pagination.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

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

func (m *QueryPlanRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PlanId != 0 {
		n += 1 + sovQuery(uint64(m.PlanId))
	}
	return n
}

func (m *QueryPlanResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Plan != nil {
		l = m.Plan.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryPositionRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Farmer)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.StakingCoinDenom)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryPositionResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.StakedCoins) > 0 {
		for _, e := range m.StakedCoins {
			l = e.Size()
			n += 1 + l + sovQuery(uint64(l))
		}
	}
	if len(m.QueuedCoins) > 0 {
		for _, e := range m.QueuedCoins {
			l = e.Size()
			n += 1 + l + sovQuery(uint64(l))
		}
	}
	if len(m.Rewards) > 0 {
		for _, e := range m.Rewards {
			l = e.Size()
			n += 1 + l + sovQuery(uint64(l))
		}
	}
	return n
}

func (m *QueryStakingsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Farmer)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.StakingCoinDenom)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if m.Pagination != nil {
		l = m.Pagination.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

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

func (m *QueryQueuedStakingsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Farmer)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.StakingCoinDenom)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if m.Pagination != nil {
		l = m.Pagination.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

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

func (m *QueryTotalStakingsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.StakingCoinDenom)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryTotalStakingsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Amount.Size()
	n += 1 + l + sovQuery(uint64(l))
	return n
}

func (m *QueryRewardsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Farmer)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.StakingCoinDenom)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if m.Pagination != nil {
		l = m.Pagination.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

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

func (m *QueryUnharvestedRewardsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Farmer)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.StakingCoinDenom)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if m.Pagination != nil {
		l = m.Pagination.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

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

func (m *QueryCurrentEpochDaysRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *QueryCurrentEpochDaysResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CurrentEpochDays != 0 {
		n += 1 + sovQuery(uint64(m.CurrentEpochDays))
	}
	return n
}

func (m *StakingResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.StakingCoinDenom)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = m.Amount.Size()
	n += 1 + l + sovQuery(uint64(l))
	if m.StartingEpoch != 0 {
		n += 1 + sovQuery(uint64(m.StartingEpoch))
	}
	return n
}

func (m *QueuedStakingResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.StakingCoinDenom)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = m.Amount.Size()
	n += 1 + l + sovQuery(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.EndTime)
	n += 1 + l + sovQuery(uint64(l))
	return n
}

func (m *RewardsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.StakingCoinDenom)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if len(m.Rewards) > 0 {
		for _, e := range m.Rewards {
			l = e.Size()
			n += 1 + l + sovQuery(uint64(l))
		}
	}
	return n
}

func (m *UnharvestedRewardsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.StakingCoinDenom)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if len(m.Rewards) > 0 {
		for _, e := range m.Rewards {
			l = e.Size()
			n += 1 + l + sovQuery(uint64(l))
		}
	}
	return n
}

func sovQuery(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozQuery(x uint64) (n int) {
	return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *QueryParamsRequest) 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 ErrIntOverflowQuery
			}
			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: QueryParamsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryParamsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryPlansRequest) 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 ErrIntOverflowQuery
			}
			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: QueryPlansRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryPlansRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				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 ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Type = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FarmingPoolAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				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 ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FarmingPoolAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TerminationAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				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 ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TerminationAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StakingCoinDenom", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				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 ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StakingCoinDenom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Terminated", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				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 ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Terminated = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			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 ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			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
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryPositionRequest) 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 ErrIntOverflowQuery
			}
			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: QueryPositionRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryPositionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Farmer", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				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 ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Farmer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StakingCoinDenom", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				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 ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StakingCoinDenom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryTotalStakingsRequest) 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 ErrIntOverflowQuery
			}
			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: QueryTotalStakingsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryTotalStakingsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StakingCoinDenom", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				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 ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StakingCoinDenom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryTotalStakingsResponse) 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 ErrIntOverflowQuery
			}
			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: QueryTotalStakingsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryTotalStakingsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				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 ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryCurrentEpochDaysRequest) 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 ErrIntOverflowQuery
			}
			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: QueryCurrentEpochDaysRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryCurrentEpochDaysRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

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

var (
	ErrInvalidLengthQuery        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowQuery          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupQuery = fmt.Errorf("proto: unexpected end of group")
)