query.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: katana/incentive/v1/query.proto

package incentive

import (
	context "context"
	fmt "fmt"
	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
	types "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"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

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

// TotalBond tracks the amount of coins of one uToken denomination bonded to a
// given reward tier without specifying an account.
type TotalBond struct {
	Tier   uint32     `protobuf:"varint,1,opt,name=tier,proto3" json:"tier,omitempty"`
	Amount types.Coin `protobuf:"bytes,2,opt,name=amount,proto3" json:"amount"`
}

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

var xxx_messageInfo_TotalBond proto.InternalMessageInfo

func (m *TotalBond) GetTier() uint32 {
	if m != nil {
		return m.Tier
	}
	return 0
}

func (m *TotalBond) GetAmount() types.Coin {
	if m != nil {
		return m.Amount
	}
	return types.Coin{}
}

// QueryParams defines the request structure for the Params gRPC service
// handler.
type QueryParams struct {
}

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

var xxx_messageInfo_QueryParams proto.InternalMessageInfo

// QueryParamsResponse defines the response structure for the Params gRPC
// service handler.
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_98af6650734ce845, []int{2}
}
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{}
}

// QueryPendingRewards defines the request structure for the PendingRewards gRPC service handler.
type QueryPendingRewards struct {
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
}

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

var xxx_messageInfo_QueryPendingRewards proto.InternalMessageInfo

func (m *QueryPendingRewards) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

// QueryPendingRewardsResponse defines the response structure for the PendingRewards gRPC service handler.
type QueryPendingRewardsResponse struct {
	Rewards github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,1,rep,name=rewards,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"rewards"`
}

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

var xxx_messageInfo_QueryPendingRewardsResponse proto.InternalMessageInfo

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

// QueryBonded defines the request structure for the Bonded gRPC service handler.
type QueryBonded struct {
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
}

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

var xxx_messageInfo_QueryBonded proto.InternalMessageInfo

func (m *QueryBonded) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

// QueryBondedResponse defines the response structure for the Bonded gRPC service handler.
type QueryBondedResponse struct {
	Bonded []TotalBond `protobuf:"bytes,1,rep,name=bonded,proto3" json:"bonded"`
}

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

var xxx_messageInfo_QueryBondedResponse proto.InternalMessageInfo

func (m *QueryBondedResponse) GetBonded() []TotalBond {
	if m != nil {
		return m.Bonded
	}
	return nil
}

// QueryUnbondings defines the request structure for the Unbondings gRPC service handler.
type QueryUnbondings struct {
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
}

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

var xxx_messageInfo_QueryUnbondings proto.InternalMessageInfo

func (m *QueryUnbondings) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

// QueryUnbondingsResponse defines the response structure for the Unbondings gRPC service handler.
type QueryUnbondingsResponse struct {
	Unbondings []Unbonding `protobuf:"bytes,1,rep,name=unbondings,proto3" json:"unbondings"`
}

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

var xxx_messageInfo_QueryUnbondingsResponse proto.InternalMessageInfo

func (m *QueryUnbondingsResponse) GetUnbondings() []Unbonding {
	if m != nil {
		return m.Unbondings
	}
	return nil
}

// QueryTotalBonded defines the request structure for the TotalBonded gRPC service handler.
type QueryTotalBonded struct {
}

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

var xxx_messageInfo_QueryTotalBonded proto.InternalMessageInfo

// QueryTotalBondedResponse defines the response structure for the TotalBonded gRPC service handler.
type QueryTotalBondedResponse struct {
	Bonded []TotalBond `protobuf:"bytes,1,rep,name=bonded,proto3" json:"bonded"`
}

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

var xxx_messageInfo_QueryTotalBondedResponse proto.InternalMessageInfo

func (m *QueryTotalBondedResponse) GetBonded() []TotalBond {
	if m != nil {
		return m.Bonded
	}
	return nil
}

// QueryUpcomingIncentivePrograms defines the request structure for the
// OngoingIncentivePrograms and UpcomingIncentivePrograms gRPC service handlers.
type QueryUpcomingIncentivePrograms struct {
}

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

var xxx_messageInfo_QueryUpcomingIncentivePrograms proto.InternalMessageInfo

// QueryUpcomingIncentiveProgramsResponse defines the response structure for the
// OngoingIncentivePrograms and UpcomingIncentivePrograms gRPC service handlers.
type QueryUpcomingIncentiveProgramsResponse struct {
	Programs []IncentiveProgram `protobuf:"bytes,1,rep,name=programs,proto3" json:"programs"`
}

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

var xxx_messageInfo_QueryUpcomingIncentiveProgramsResponse proto.InternalMessageInfo

func (m *QueryUpcomingIncentiveProgramsResponse) GetPrograms() []IncentiveProgram {
	if m != nil {
		return m.Programs
	}
	return nil
}

// QueryOngoingIncentivePrograms defines the request structure for the
// OngoingIncentivePrograms and UpcomingIncentivePrograms gRPC service handlers.
type QueryOngoingIncentivePrograms struct {
}

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

var xxx_messageInfo_QueryOngoingIncentivePrograms proto.InternalMessageInfo

// QueryOngoingIncentiveProgramsResponse defines the response structure for the
// OngoingIncentivePrograms and UpcomingIncentivePrograms gRPC service handlers.
type QueryOngoingIncentiveProgramsResponse struct {
	Programs []IncentiveProgram `protobuf:"bytes,1,rep,name=programs,proto3" json:"programs"`
}

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

var xxx_messageInfo_QueryOngoingIncentiveProgramsResponse proto.InternalMessageInfo

func (m *QueryOngoingIncentiveProgramsResponse) GetPrograms() []IncentiveProgram {
	if m != nil {
		return m.Programs
	}
	return nil
}

// QueryCompletedIncentivePrograms defines the request structure for the
// CompletedIncentivePrograms gRPC service handler.
type QueryCompletedIncentivePrograms struct {
	// pagination defines an optional pagination for the request.
	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryCompletedIncentivePrograms proto.InternalMessageInfo

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

// QueryCompletedIncentiveProgramsResponse defines the response structure for the
// CompletedIncentivePrograms gRPC service handler.
type QueryCompletedIncentiveProgramsResponse struct {
	Programs []IncentiveProgram `protobuf:"bytes,1,rep,name=programs,proto3" json:"programs"`
	// pagination defines an optional pagination for the request.
	Pagination *query.PageRequest `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryCompletedIncentiveProgramsResponse proto.InternalMessageInfo

func (m *QueryCompletedIncentiveProgramsResponse) GetPrograms() []IncentiveProgram {
	if m != nil {
		return m.Programs
	}
	return nil
}

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

// QueryIncentiveProgram defines the request structure for the IncentiveProgram
// gRPC service handler.
type QueryIncentiveProgram struct {
	// ID specifies which program to query for
	Id uint32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
}

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

var xxx_messageInfo_QueryIncentiveProgram proto.InternalMessageInfo

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

// QueryIncentivePrograResponse defines the response structure for the
// IncentiveProgram gRPC service handler.
type QueryIncentiveProgramResponse struct {
	Program IncentiveProgram `protobuf:"bytes,1,opt,name=program,proto3" json:"program"`
}

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

var xxx_messageInfo_QueryIncentiveProgramResponse proto.InternalMessageInfo

func (m *QueryIncentiveProgramResponse) GetProgram() IncentiveProgram {
	if m != nil {
		return m.Program
	}
	return IncentiveProgram{}
}

func init() {
	proto.RegisterType((*TotalBond)(nil), "mokitanetwork.katana.incentive.v1.TotalBond")
	proto.RegisterType((*QueryParams)(nil), "mokitanetwork.katana.incentive.v1.QueryParams")
	proto.RegisterType((*QueryParamsResponse)(nil), "mokitanetwork.katana.incentive.v1.QueryParamsResponse")
	proto.RegisterType((*QueryPendingRewards)(nil), "mokitanetwork.katana.incentive.v1.QueryPendingRewards")
	proto.RegisterType((*QueryPendingRewardsResponse)(nil), "mokitanetwork.katana.incentive.v1.QueryPendingRewardsResponse")
	proto.RegisterType((*QueryBonded)(nil), "mokitanetwork.katana.incentive.v1.QueryBonded")
	proto.RegisterType((*QueryBondedResponse)(nil), "mokitanetwork.katana.incentive.v1.QueryBondedResponse")
	proto.RegisterType((*QueryUnbondings)(nil), "mokitanetwork.katana.incentive.v1.QueryUnbondings")
	proto.RegisterType((*QueryUnbondingsResponse)(nil), "mokitanetwork.katana.incentive.v1.QueryUnbondingsResponse")
	proto.RegisterType((*QueryTotalBonded)(nil), "mokitanetwork.katana.incentive.v1.QueryTotalBonded")
	proto.RegisterType((*QueryTotalBondedResponse)(nil), "mokitanetwork.katana.incentive.v1.QueryTotalBondedResponse")
	proto.RegisterType((*QueryUpcomingIncentivePrograms)(nil), "mokitanetwork.katana.incentive.v1.QueryUpcomingIncentivePrograms")
	proto.RegisterType((*QueryUpcomingIncentiveProgramsResponse)(nil), "mokitanetwork.katana.incentive.v1.QueryUpcomingIncentiveProgramsResponse")
	proto.RegisterType((*QueryOngoingIncentivePrograms)(nil), "mokitanetwork.katana.incentive.v1.QueryOngoingIncentivePrograms")
	proto.RegisterType((*QueryOngoingIncentiveProgramsResponse)(nil), "mokitanetwork.katana.incentive.v1.QueryOngoingIncentiveProgramsResponse")
	proto.RegisterType((*QueryCompletedIncentivePrograms)(nil), "mokitanetwork.katana.incentive.v1.QueryCompletedIncentivePrograms")
	proto.RegisterType((*QueryCompletedIncentiveProgramsResponse)(nil), "mokitanetwork.katana.incentive.v1.QueryCompletedIncentiveProgramsResponse")
	proto.RegisterType((*QueryIncentiveProgram)(nil), "mokitanetwork.katana.incentive.v1.QueryIncentiveProgram")
	proto.RegisterType((*QueryIncentiveProgramResponse)(nil), "mokitanetwork.katana.incentive.v1.QueryIncentiveProgramResponse")
}

func init() { proto.RegisterFile("katana/incentive/v1/query.proto", fileDescriptor_98af6650734ce845) }

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

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

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

// 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 queries the parameters of the x/incentive module.
	Params(ctx context.Context, in *QueryParams, opts ...grpc.CallOption) (*QueryParamsResponse, error)
	// PendingRewards queries unclaimed incentive rewards associated with an account.
	PendingRewards(ctx context.Context, in *QueryPendingRewards, opts ...grpc.CallOption) (*QueryPendingRewardsResponse, error)
	// Bonded queries all bonded collateral uTokens associated with an account.
	Bonded(ctx context.Context, in *QueryBonded, opts ...grpc.CallOption) (*QueryBondedResponse, error)
	// Unbondings queries all current uToken unbondings associated with an account.
	Unbondings(ctx context.Context, in *QueryUnbondings, opts ...grpc.CallOption) (*QueryUnbondingsResponse, error)
	// TotalBonded queries the sum of all bonded collateral uTokens, separated by tier.
	TotalBonded(ctx context.Context, in *QueryTotalBonded, opts ...grpc.CallOption) (*QueryTotalBondedResponse, error)
	// CompletedIncentivePrograms queries for all incentives programs that have been passed
	// by governance, and either run to completion or expired immediately due to not being funded.
	CompletedIncentivePrograms(ctx context.Context, in *QueryCompletedIncentivePrograms, opts ...grpc.CallOption) (*QueryCompletedIncentiveProgramsResponse, error)
	// OngoingIncentivePrograms queries for all incentives programs that have been passed
	// by governance, funded, and started but not yet completed.
	OngoingIncentivePrograms(ctx context.Context, in *QueryOngoingIncentivePrograms, opts ...grpc.CallOption) (*QueryOngoingIncentiveProgramsResponse, error)
	// UpcomingIncentivePrograms queries for all incentives programs that have been passed
	// by governance, but not yet started. They may or may not have been funded.
	UpcomingIncentivePrograms(ctx context.Context, in *QueryUpcomingIncentivePrograms, opts ...grpc.CallOption) (*QueryUpcomingIncentiveProgramsResponse, error)
	// IncentiveProgram queries a single incentive program by ID.
	IncentiveProgram(ctx context.Context, in *QueryIncentiveProgram, opts ...grpc.CallOption) (*QueryIncentiveProgramResponse, error)
}

type queryClient struct {
	cc grpc1.ClientConn
}

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

func (c *queryClient) Params(ctx context.Context, in *QueryParams, opts ...grpc.CallOption) (*QueryParamsResponse, error) {
	out := new(QueryParamsResponse)
	err := c.cc.Invoke(ctx, "/mokitanetwork.katana.incentive.v1.Query/Params", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) PendingRewards(ctx context.Context, in *QueryPendingRewards, opts ...grpc.CallOption) (*QueryPendingRewardsResponse, error) {
	out := new(QueryPendingRewardsResponse)
	err := c.cc.Invoke(ctx, "/mokitanetwork.katana.incentive.v1.Query/PendingRewards", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) Bonded(ctx context.Context, in *QueryBonded, opts ...grpc.CallOption) (*QueryBondedResponse, error) {
	out := new(QueryBondedResponse)
	err := c.cc.Invoke(ctx, "/mokitanetwork.katana.incentive.v1.Query/Bonded", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) Unbondings(ctx context.Context, in *QueryUnbondings, opts ...grpc.CallOption) (*QueryUnbondingsResponse, error) {
	out := new(QueryUnbondingsResponse)
	err := c.cc.Invoke(ctx, "/mokitanetwork.katana.incentive.v1.Query/Unbondings", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) TotalBonded(ctx context.Context, in *QueryTotalBonded, opts ...grpc.CallOption) (*QueryTotalBondedResponse, error) {
	out := new(QueryTotalBondedResponse)
	err := c.cc.Invoke(ctx, "/mokitanetwork.katana.incentive.v1.Query/TotalBonded", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) CompletedIncentivePrograms(ctx context.Context, in *QueryCompletedIncentivePrograms, opts ...grpc.CallOption) (*QueryCompletedIncentiveProgramsResponse, error) {
	out := new(QueryCompletedIncentiveProgramsResponse)
	err := c.cc.Invoke(ctx, "/mokitanetwork.katana.incentive.v1.Query/CompletedIncentivePrograms", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) OngoingIncentivePrograms(ctx context.Context, in *QueryOngoingIncentivePrograms, opts ...grpc.CallOption) (*QueryOngoingIncentiveProgramsResponse, error) {
	out := new(QueryOngoingIncentiveProgramsResponse)
	err := c.cc.Invoke(ctx, "/mokitanetwork.katana.incentive.v1.Query/OngoingIncentivePrograms", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) UpcomingIncentivePrograms(ctx context.Context, in *QueryUpcomingIncentivePrograms, opts ...grpc.CallOption) (*QueryUpcomingIncentiveProgramsResponse, error) {
	out := new(QueryUpcomingIncentiveProgramsResponse)
	err := c.cc.Invoke(ctx, "/mokitanetwork.katana.incentive.v1.Query/UpcomingIncentivePrograms", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) IncentiveProgram(ctx context.Context, in *QueryIncentiveProgram, opts ...grpc.CallOption) (*QueryIncentiveProgramResponse, error) {
	out := new(QueryIncentiveProgramResponse)
	err := c.cc.Invoke(ctx, "/mokitanetwork.katana.incentive.v1.Query/IncentiveProgram", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// QueryServer is the server API for Query service.
type QueryServer interface {
	// Params queries the parameters of the x/incentive module.
	Params(context.Context, *QueryParams) (*QueryParamsResponse, error)
	// PendingRewards queries unclaimed incentive rewards associated with an account.
	PendingRewards(context.Context, *QueryPendingRewards) (*QueryPendingRewardsResponse, error)
	// Bonded queries all bonded collateral uTokens associated with an account.
	Bonded(context.Context, *QueryBonded) (*QueryBondedResponse, error)
	// Unbondings queries all current uToken unbondings associated with an account.
	Unbondings(context.Context, *QueryUnbondings) (*QueryUnbondingsResponse, error)
	// TotalBonded queries the sum of all bonded collateral uTokens, separated by tier.
	TotalBonded(context.Context, *QueryTotalBonded) (*QueryTotalBondedResponse, error)
	// CompletedIncentivePrograms queries for all incentives programs that have been passed
	// by governance, and either run to completion or expired immediately due to not being funded.
	CompletedIncentivePrograms(context.Context, *QueryCompletedIncentivePrograms) (*QueryCompletedIncentiveProgramsResponse, error)
	// OngoingIncentivePrograms queries for all incentives programs that have been passed
	// by governance, funded, and started but not yet completed.
	OngoingIncentivePrograms(context.Context, *QueryOngoingIncentivePrograms) (*QueryOngoingIncentiveProgramsResponse, error)
	// UpcomingIncentivePrograms queries for all incentives programs that have been passed
	// by governance, but not yet started. They may or may not have been funded.
	UpcomingIncentivePrograms(context.Context, *QueryUpcomingIncentivePrograms) (*QueryUpcomingIncentiveProgramsResponse, error)
	// IncentiveProgram queries a single incentive program by ID.
	IncentiveProgram(context.Context, *QueryIncentiveProgram) (*QueryIncentiveProgramResponse, error)
}

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

func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParams) (*QueryParamsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Params not implemented")
}
func (*UnimplementedQueryServer) PendingRewards(ctx context.Context, req *QueryPendingRewards) (*QueryPendingRewardsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PendingRewards not implemented")
}
func (*UnimplementedQueryServer) Bonded(ctx context.Context, req *QueryBonded) (*QueryBondedResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Bonded not implemented")
}
func (*UnimplementedQueryServer) Unbondings(ctx context.Context, req *QueryUnbondings) (*QueryUnbondingsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Unbondings not implemented")
}
func (*UnimplementedQueryServer) TotalBonded(ctx context.Context, req *QueryTotalBonded) (*QueryTotalBondedResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TotalBonded not implemented")
}
func (*UnimplementedQueryServer) CompletedIncentivePrograms(ctx context.Context, req *QueryCompletedIncentivePrograms) (*QueryCompletedIncentiveProgramsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CompletedIncentivePrograms not implemented")
}
func (*UnimplementedQueryServer) OngoingIncentivePrograms(ctx context.Context, req *QueryOngoingIncentivePrograms) (*QueryOngoingIncentiveProgramsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method OngoingIncentivePrograms not implemented")
}
func (*UnimplementedQueryServer) UpcomingIncentivePrograms(ctx context.Context, req *QueryUpcomingIncentivePrograms) (*QueryUpcomingIncentiveProgramsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpcomingIncentivePrograms not implemented")
}
func (*UnimplementedQueryServer) IncentiveProgram(ctx context.Context, req *QueryIncentiveProgram) (*QueryIncentiveProgramResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method IncentiveProgram 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(QueryParams)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Params(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/mokitanetwork.katana.incentive.v1.Query/Params",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Params(ctx, req.(*QueryParams))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_PendingRewards_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryPendingRewards)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).PendingRewards(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/mokitanetwork.katana.incentive.v1.Query/PendingRewards",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).PendingRewards(ctx, req.(*QueryPendingRewards))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_Bonded_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryBonded)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Bonded(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/mokitanetwork.katana.incentive.v1.Query/Bonded",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Bonded(ctx, req.(*QueryBonded))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_Unbondings_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryUnbondings)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Unbondings(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/mokitanetwork.katana.incentive.v1.Query/Unbondings",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Unbondings(ctx, req.(*QueryUnbondings))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_TotalBonded_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryTotalBonded)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).TotalBonded(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/mokitanetwork.katana.incentive.v1.Query/TotalBonded",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).TotalBonded(ctx, req.(*QueryTotalBonded))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_CompletedIncentivePrograms_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryCompletedIncentivePrograms)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).CompletedIncentivePrograms(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/mokitanetwork.katana.incentive.v1.Query/CompletedIncentivePrograms",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).CompletedIncentivePrograms(ctx, req.(*QueryCompletedIncentivePrograms))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_OngoingIncentivePrograms_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryOngoingIncentivePrograms)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).OngoingIncentivePrograms(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/mokitanetwork.katana.incentive.v1.Query/OngoingIncentivePrograms",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).OngoingIncentivePrograms(ctx, req.(*QueryOngoingIncentivePrograms))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_UpcomingIncentivePrograms_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryUpcomingIncentivePrograms)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).UpcomingIncentivePrograms(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/mokitanetwork.katana.incentive.v1.Query/UpcomingIncentivePrograms",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).UpcomingIncentivePrograms(ctx, req.(*QueryUpcomingIncentivePrograms))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_IncentiveProgram_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryIncentiveProgram)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).IncentiveProgram(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/mokitanetwork.katana.incentive.v1.Query/IncentiveProgram",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).IncentiveProgram(ctx, req.(*QueryIncentiveProgram))
	}
	return interceptor(ctx, in, info, handler)
}

var _Query_serviceDesc = grpc.ServiceDesc{
	ServiceName: "mokitanetwork.katana.incentive.v1.Query",
	HandlerType: (*QueryServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Params",
			Handler:    _Query_Params_Handler,
		},
		{
			MethodName: "PendingRewards",
			Handler:    _Query_PendingRewards_Handler,
		},
		{
			MethodName: "Bonded",
			Handler:    _Query_Bonded_Handler,
		},
		{
			MethodName: "Unbondings",
			Handler:    _Query_Unbondings_Handler,
		},
		{
			MethodName: "TotalBonded",
			Handler:    _Query_TotalBonded_Handler,
		},
		{
			MethodName: "CompletedIncentivePrograms",
			Handler:    _Query_CompletedIncentivePrograms_Handler,
		},
		{
			MethodName: "OngoingIncentivePrograms",
			Handler:    _Query_OngoingIncentivePrograms_Handler,
		},
		{
			MethodName: "UpcomingIncentivePrograms",
			Handler:    _Query_UpcomingIncentivePrograms_Handler,
		},
		{
			MethodName: "IncentiveProgram",
			Handler:    _Query_IncentiveProgram_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "katana/incentive/v1/query.proto",
}

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

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

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

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

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

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

func (m *QueryPendingRewardsResponse) 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] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *QueryBondedResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Bonded) > 0 {
		for iNdEx := len(m.Bonded) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Bonded[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 *QueryUnbondings) 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 *QueryUnbondings) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *QueryUnbondingsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Unbondings) > 0 {
		for iNdEx := len(m.Unbondings) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Unbondings[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 *QueryTotalBonded) 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 *QueryTotalBonded) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *QueryTotalBondedResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Bonded) > 0 {
		for iNdEx := len(m.Bonded) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Bonded[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 *QueryUpcomingIncentivePrograms) 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 *QueryUpcomingIncentivePrograms) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *QueryUpcomingIncentiveProgramsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Programs) > 0 {
		for iNdEx := len(m.Programs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Programs[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 *QueryOngoingIncentivePrograms) 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 *QueryOngoingIncentivePrograms) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *QueryOngoingIncentiveProgramsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Programs) > 0 {
		for iNdEx := len(m.Programs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Programs[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 *QueryCompletedIncentivePrograms) 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 *QueryCompletedIncentivePrograms) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryCompletedIncentivePrograms) 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] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *QueryCompletedIncentiveProgramsResponse) 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.Programs) > 0 {
		for iNdEx := len(m.Programs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Programs[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 *QueryIncentiveProgram) 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 *QueryIncentiveProgram) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *QueryIncentiveProgramResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Program.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 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 *TotalBond) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Tier != 0 {
		n += 1 + sovQuery(uint64(m.Tier))
	}
	l = m.Amount.Size()
	n += 1 + l + sovQuery(uint64(l))
	return n
}

func (m *QueryParams) 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 *QueryPendingRewards) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryPendingRewardsResponse) 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))
		}
	}
	return n
}

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

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

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

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

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

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

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

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

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

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

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

func (m *QueryCompletedIncentiveProgramsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Programs) > 0 {
		for _, e := range m.Programs {
			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 *QueryIncentiveProgram) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + sovQuery(uint64(m.Id))
	}
	return n
}

func (m *QueryIncentiveProgramResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Program.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 *TotalBond) 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: TotalBond: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TotalBond: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tier", wireType)
			}
			m.Tier = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Tier |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", 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.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 *QueryParams) 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: QueryParams: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryParams: 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 *QueryPendingRewards) 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: QueryPendingRewards: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryPendingRewards: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", 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.Address = 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 *QueryPendingRewardsResponse) 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: QueryPendingRewardsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryPendingRewardsResponse: 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, types.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 *QueryBonded) 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: QueryBonded: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryBonded: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", 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.Address = 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 *QueryBondedResponse) 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: QueryBondedResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryBondedResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Bonded", 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.Bonded = append(m.Bonded, TotalBond{})
			if err := m.Bonded[len(m.Bonded)-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 *QueryUnbondings) 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: QueryUnbondings: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryUnbondings: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", 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.Address = 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 *QueryUnbondingsResponse) 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: QueryUnbondingsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryUnbondingsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Unbondings", 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.Unbondings = append(m.Unbondings, Unbonding{})
			if err := m.Unbondings[len(m.Unbondings)-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 *QueryTotalBonded) 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: QueryTotalBonded: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryTotalBonded: 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 *QueryTotalBondedResponse) 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: QueryTotalBondedResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryTotalBondedResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Bonded", 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.Bonded = append(m.Bonded, TotalBond{})
			if err := m.Bonded[len(m.Bonded)-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 *QueryUpcomingIncentivePrograms) 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: QueryUpcomingIncentivePrograms: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryUpcomingIncentivePrograms: 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 *QueryUpcomingIncentiveProgramsResponse) 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: QueryUpcomingIncentiveProgramsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryUpcomingIncentiveProgramsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Programs", 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.Programs = append(m.Programs, IncentiveProgram{})
			if err := m.Programs[len(m.Programs)-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 *QueryOngoingIncentivePrograms) 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: QueryOngoingIncentivePrograms: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryOngoingIncentivePrograms: 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 *QueryOngoingIncentiveProgramsResponse) 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: QueryOngoingIncentiveProgramsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryOngoingIncentiveProgramsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Programs", 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.Programs = append(m.Programs, IncentiveProgram{})
			if err := m.Programs[len(m.Programs)-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 *QueryCompletedIncentivePrograms) 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: QueryCompletedIncentivePrograms: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryCompletedIncentivePrograms: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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 *QueryCompletedIncentiveProgramsResponse) 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: QueryCompletedIncentiveProgramsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryCompletedIncentiveProgramsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Programs", 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.Programs = append(m.Programs, IncentiveProgram{})
			if err := m.Programs[len(m.Programs)-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.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 *QueryIncentiveProgram) 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: QueryIncentiveProgram: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryIncentiveProgram: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= 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 *QueryIncentiveProgramResponse) 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: QueryIncentiveProgramResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryIncentiveProgramResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Program", 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.Program.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")
)