query.pb.go

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

package types

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/cosmos/gogoproto/gogoproto"
	grpc1 "github.com/gogo/protobuf/grpc"
	proto "github.com/gogo/protobuf/proto"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

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

// QueryTaxRateRequest is the request type for the Query/TaxRate RPC method.
type QueryTaxRateRequest struct {
}

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

var xxx_messageInfo_QueryTaxRateRequest proto.InternalMessageInfo

// QueryTaxRateResponse is response type for the
// Query/TaxRate RPC method.
type QueryTaxRateResponse struct {
	TaxRate github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,1,opt,name=tax_rate,json=taxRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"tax_rate"`
}

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

var xxx_messageInfo_QueryTaxRateResponse proto.InternalMessageInfo

// QueryTaxCapRequest is the request type for the Query/TaxCap RPC method.
type QueryTaxCapRequest struct {
	// denom defines the denomination to query for.
	Denom string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"`
}

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

var xxx_messageInfo_QueryTaxCapRequest proto.InternalMessageInfo

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

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

var xxx_messageInfo_QueryTaxCapResponse proto.InternalMessageInfo

// QueryTaxCapsRequest is the request type for the Query/TaxCaps RPC method.
type QueryTaxCapsRequest struct {
}

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

var xxx_messageInfo_QueryTaxCapsRequest proto.InternalMessageInfo

// QueryTaxCapsResponseItem is response item type for the
// Query/TaxCaps RPC method.
type QueryTaxCapsResponseItem struct {
	Denom  string                                 `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"`
	TaxCap github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=tax_cap,json=taxCap,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"tax_cap"`
}

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

var xxx_messageInfo_QueryTaxCapsResponseItem proto.InternalMessageInfo

func (m *QueryTaxCapsResponseItem) GetDenom() string {
	if m != nil {
		return m.Denom
	}
	return ""
}

// QueryTaxCapsResponse is response type for the
// Query/TaxCaps RPC method.
type QueryTaxCapsResponse struct {
	TaxCaps []QueryTaxCapsResponseItem `protobuf:"bytes,1,rep,name=tax_caps,json=taxCaps,proto3" json:"tax_caps"`
}

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

var xxx_messageInfo_QueryTaxCapsResponse proto.InternalMessageInfo

func (m *QueryTaxCapsResponse) GetTaxCaps() []QueryTaxCapsResponseItem {
	if m != nil {
		return m.TaxCaps
	}
	return nil
}

// QueryRewardWeightRequest is the request type for the Query/RewardWeight RPC method.
type QueryRewardWeightRequest struct {
}

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

var xxx_messageInfo_QueryRewardWeightRequest proto.InternalMessageInfo

// QueryRewardWeightResponse is response type for the
// Query/RewardWeight RPC method.
type QueryRewardWeightResponse struct {
	RewardWeight github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,1,opt,name=reward_weight,json=rewardWeight,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"reward_weight"`
}

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

var xxx_messageInfo_QueryRewardWeightResponse proto.InternalMessageInfo

// QueryTaxProceedsRequest is the request type for the Query/TaxProceeds RPC method.
type QueryTaxProceedsRequest struct {
}

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

var xxx_messageInfo_QueryTaxProceedsRequest proto.InternalMessageInfo

// QueryTaxProceedsResponse is response type for the
// Query/TaxProceeds RPC method.
type QueryTaxProceedsResponse struct {
	TaxProceeds github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,1,rep,name=tax_proceeds,json=taxProceeds,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"tax_proceeds"`
}

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

var xxx_messageInfo_QueryTaxProceedsResponse proto.InternalMessageInfo

func (m *QueryTaxProceedsResponse) GetTaxProceeds() github_com_cosmos_cosmos_sdk_types.Coins {
	if m != nil {
		return m.TaxProceeds
	}
	return nil
}

// QuerySeigniorageProceedsRequest is the request type for the Query/SeigniorageProceeds RPC method.
type QuerySeigniorageProceedsRequest struct {
}

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

var xxx_messageInfo_QuerySeigniorageProceedsRequest proto.InternalMessageInfo

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

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

var xxx_messageInfo_QuerySeigniorageProceedsResponse proto.InternalMessageInfo

// QueryIndicatorsRequest is the request type for the Query/Indicators RPC method.
type QueryIndicatorsRequest struct {
}

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

var xxx_messageInfo_QueryIndicatorsRequest proto.InternalMessageInfo

// QueryIndicatorsResponse is response type for the
// Query/Indicators RPC method.
type QueryIndicatorsResponse struct {
	TRLYear  github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,1,opt,name=trl_year,json=trlYear,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"trl_year"`
	TRLMonth github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=trl_month,json=trlMonth,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"trl_month"`
}

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

var xxx_messageInfo_QueryIndicatorsResponse proto.InternalMessageInfo

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

func (m *QueryParamsRequest) Reset()         { *m = QueryParamsRequest{} }
func (m *QueryParamsRequest) String() string { return proto.CompactTextString(m) }
func (*QueryParamsRequest) ProtoMessage()    {}
func (*QueryParamsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_699c8c29293c9a9b, []int{15}
}
func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryParamsRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryParamsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryParamsRequest.Merge(m, src)
}
func (m *QueryParamsRequest) XXX_Size() int {
	return m.Size()
}
func (m *QueryParamsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryParamsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryParamsRequest proto.InternalMessageInfo

// QueryParamsResponse is the response type for the Query/Params RPC method.
type QueryParamsResponse struct {
	// params defines the parameters of the module.
	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_699c8c29293c9a9b, []int{16}
}
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{}
}

// QueryBurnTaxExemptionListRequest is the request type for the Query/BurnTaxExemptionList RPC method.
type QueryBurnTaxExemptionListRequest struct {
	Pagination *query.PageRequest `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryBurnTaxExemptionListRequest proto.InternalMessageInfo

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

// QueryBurnTaxExemptionListResponse is response type for the Query/BurnTaxExemptionList RPC method.
type QueryBurnTaxExemptionListResponse struct {
	Addresses  []string            `protobuf:"bytes,1,rep,name=addresses,proto3" json:"addresses,omitempty"`
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryBurnTaxExemptionListResponse proto.InternalMessageInfo

func (m *QueryBurnTaxExemptionListResponse) GetAddresses() []string {
	if m != nil {
		return m.Addresses
	}
	return nil
}

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

func init() {
	proto.RegisterType((*QueryTaxRateRequest)(nil), "terra.treasury.v1beta1.QueryTaxRateRequest")
	proto.RegisterType((*QueryTaxRateResponse)(nil), "terra.treasury.v1beta1.QueryTaxRateResponse")
	proto.RegisterType((*QueryTaxCapRequest)(nil), "terra.treasury.v1beta1.QueryTaxCapRequest")
	proto.RegisterType((*QueryTaxCapResponse)(nil), "terra.treasury.v1beta1.QueryTaxCapResponse")
	proto.RegisterType((*QueryTaxCapsRequest)(nil), "terra.treasury.v1beta1.QueryTaxCapsRequest")
	proto.RegisterType((*QueryTaxCapsResponseItem)(nil), "terra.treasury.v1beta1.QueryTaxCapsResponseItem")
	proto.RegisterType((*QueryTaxCapsResponse)(nil), "terra.treasury.v1beta1.QueryTaxCapsResponse")
	proto.RegisterType((*QueryRewardWeightRequest)(nil), "terra.treasury.v1beta1.QueryRewardWeightRequest")
	proto.RegisterType((*QueryRewardWeightResponse)(nil), "terra.treasury.v1beta1.QueryRewardWeightResponse")
	proto.RegisterType((*QueryTaxProceedsRequest)(nil), "terra.treasury.v1beta1.QueryTaxProceedsRequest")
	proto.RegisterType((*QueryTaxProceedsResponse)(nil), "terra.treasury.v1beta1.QueryTaxProceedsResponse")
	proto.RegisterType((*QuerySeigniorageProceedsRequest)(nil), "terra.treasury.v1beta1.QuerySeigniorageProceedsRequest")
	proto.RegisterType((*QuerySeigniorageProceedsResponse)(nil), "terra.treasury.v1beta1.QuerySeigniorageProceedsResponse")
	proto.RegisterType((*QueryIndicatorsRequest)(nil), "terra.treasury.v1beta1.QueryIndicatorsRequest")
	proto.RegisterType((*QueryIndicatorsResponse)(nil), "terra.treasury.v1beta1.QueryIndicatorsResponse")
	proto.RegisterType((*QueryParamsRequest)(nil), "terra.treasury.v1beta1.QueryParamsRequest")
	proto.RegisterType((*QueryParamsResponse)(nil), "terra.treasury.v1beta1.QueryParamsResponse")
	proto.RegisterType((*QueryBurnTaxExemptionListRequest)(nil), "terra.treasury.v1beta1.QueryBurnTaxExemptionListRequest")
	proto.RegisterType((*QueryBurnTaxExemptionListResponse)(nil), "terra.treasury.v1beta1.QueryBurnTaxExemptionListResponse")
}

func init() {
	proto.RegisterFile("terra/treasury/v1beta1/query.proto", fileDescriptor_699c8c29293c9a9b)
}

var fileDescriptor_699c8c29293c9a9b = []byte{
	// 1037 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x97, 0xcb, 0x6f, 0x1b, 0x45,
	0x1c, 0xc7, 0xbd, 0x85, 0x3a, 0xc9, 0x38, 0x5c, 0x26, 0xa6, 0x24, 0x56, 0x65, 0xbb, 0xa3, 0x36,
	0xb5, 0xf2, 0xd8, 0x4d, 0x42, 0xa5, 0xd2, 0x8a, 0x93, 0x0b, 0x94, 0x48, 0x41, 0x6a, 0x37, 0x96,
	0x2a, 0x38, 0x60, 0x8d, 0xd7, 0xa3, 0xcd, 0x82, 0xbd, 0xb3, 0x9d, 0x19, 0x53, 0x5b, 0x88, 0x0b,
	0x12, 0x12, 0x70, 0x40, 0x48, 0x3d, 0x71, 0x41, 0x15, 0x47, 0xee, 0x5c, 0x39, 0x71, 0xc8, 0xb1,
	0x12, 0x17, 0xc4, 0x21, 0xa0, 0x84, 0x03, 0x7f, 0x06, 0x9a, 0xc7, 0x7a, 0xd7, 0xad, 0xd7, 0xde,
	0x84, 0x53, 0x36, 0x33, 0xbf, 0xc7, 0x67, 0x5e, 0xdf, 0xaf, 0x0c, 0x90, 0x20, 0x8c, 0x61, 0x47,
	0x30, 0x82, 0xf9, 0x80, 0x8d, 0x9c, 0xcf, 0x76, 0x3b, 0x44, 0xe0, 0x5d, 0xe7, 0xf1, 0x80, 0xb0,
	0x91, 0x1d, 0x31, 0x2a, 0x28, 0xbc, 0xa2, 0x62, 0xec, 0x38, 0xc6, 0x36, 0x31, 0x95, 0xb2, 0x4f,
	0x7d, 0xaa, 0x42, 0x1c, 0xf9, 0xa5, 0xa3, 0x2b, 0x57, 0x7d, 0x4a, 0xfd, 0x1e, 0x71, 0x70, 0x14,
	0x38, 0x38, 0x0c, 0xa9, 0xc0, 0x22, 0xa0, 0x21, 0x37, 0xb3, 0x1b, 0x1e, 0xe5, 0x7d, 0xca, 0x9d,
	0x0e, 0xe6, 0x44, 0x37, 0x19, 0xb7, 0x8c, 0xb0, 0x1f, 0x84, 0x2a, 0xd8, 0xc4, 0xde, 0xc8, 0x60,
	0x1b, 0x83, 0xe8, 0xb0, 0x6a, 0xba, 0x64, 0x1c, 0xe3, 0xd1, 0xc0, 0x94, 0x41, 0xaf, 0x83, 0x95,
	0x87, 0xb2, 0x51, 0x0b, 0x0f, 0x5d, 0x2c, 0x88, 0x4b, 0x1e, 0x0f, 0x08, 0x17, 0x08, 0x83, 0xf2,
	0xe4, 0x30, 0x8f, 0x68, 0xc8, 0x09, 0xdc, 0x07, 0x8b, 0x02, 0x0f, 0xdb, 0x0c, 0x0b, 0xb2, 0x6a,
	0xd5, 0xad, 0xc6, 0x52, 0xd3, 0x3e, 0x3e, 0xa9, 0x15, 0xfe, 0x3c, 0xa9, 0xad, 0xfb, 0x81, 0x38,
	0x1a, 0x74, 0x6c, 0x8f, 0xf6, 0x1d, 0xd3, 0x53, 0xff, 0xd9, 0xe6, 0xdd, 0x4f, 0x1d, 0x31, 0x8a,
	0x08, 0xb7, 0xdf, 0x21, 0x9e, 0xbb, 0x20, 0x74, 0x49, 0x74, 0x0b, 0xc0, 0xb8, 0xc5, 0x3d, 0x1c,
	0x99, 0xc6, 0xb0, 0x0c, 0x2e, 0x77, 0x49, 0x48, 0xfb, 0xba, 0xba, 0xab, 0xff, 0xb9, 0xbb, 0xf8,
	0xf5, 0xb3, 0x5a, 0xe1, 0xdf, 0x67, 0xb5, 0x02, 0xfa, 0x38, 0xe1, 0x55, 0x59, 0x86, 0xeb, 0x3e,
	0x90, 0x75, 0xdb, 0x1e, 0x8e, 0x2e, 0x80, 0xb5, 0x1f, 0x0a, 0xb7, 0x28, 0x54, 0x41, 0x54, 0x9b,
	0xa8, 0xcf, 0x0d, 0x56, 0x0a, 0x60, 0x04, 0x56, 0x27, 0x03, 0x34, 0xc1, 0xbe, 0x20, 0xfd, 0xe9,
	0xf0, 0x69, 0xb6, 0x4b, 0xff, 0x8b, 0x2d, 0x48, 0x0e, 0x25, 0xdd, 0x1a, 0x3e, 0xd4, 0x87, 0xe2,
	0xe1, 0x88, 0xaf, 0x5a, 0xf5, 0x57, 0x1a, 0xa5, 0xbd, 0x1d, 0x7b, 0xfa, 0xad, 0xb4, 0xb3, 0xd0,
	0x9b, 0xaf, 0x4a, 0x26, 0x75, 0x38, 0x72, 0x0a, 0x55, 0xcc, 0x2a, 0x5d, 0xf2, 0x04, 0xb3, 0xee,
	0x23, 0x12, 0xf8, 0x47, 0x22, 0xbe, 0x1b, 0x11, 0x58, 0x9b, 0x32, 0x67, 0x58, 0x0e, 0xc1, 0x6b,
	0x4c, 0x8d, 0xb7, 0x9f, 0xa8, 0x89, 0x0b, 0xde, 0x92, 0x65, 0x96, 0x2a, 0x8e, 0xd6, 0xc0, 0x1b,
	0x31, 0xf8, 0x03, 0x46, 0x3d, 0x42, 0xba, 0xf1, 0xc1, 0xa0, 0x6f, 0xad, 0xe4, 0x3c, 0x92, 0x39,
	0x03, 0x13, 0x82, 0x65, 0xb9, 0x31, 0x91, 0x19, 0x37, 0x9b, 0xb3, 0x66, 0xeb, 0x96, 0xb6, 0x7c,
	0x13, 0xe3, 0x9d, 0xb9, 0x47, 0x83, 0xb0, 0xb9, 0x23, 0x31, 0x7f, 0xfe, 0xab, 0xd6, 0xc8, 0x81,
	0x29, 0x13, 0xb8, 0x5b, 0x12, 0x49, 0x5f, 0x74, 0x0d, 0xd4, 0x14, 0xcb, 0x21, 0x09, 0xfc, 0x30,
	0xa0, 0x0c, 0xfb, 0xe4, 0x45, 0xde, 0xaf, 0x2c, 0x50, 0xcf, 0x8e, 0x31, 0xdc, 0x18, 0x94, 0x79,
	0x32, 0x9d, 0xe6, 0xbf, 0xc8, 0xf5, 0x59, 0xe1, 0x2f, 0xb7, 0x42, 0xab, 0xe0, 0x8a, 0xc2, 0xd8,
	0x0f, 0xbb, 0x81, 0x87, 0x05, 0x65, 0x63, 0xc2, 0x63, 0xcb, 0xec, 0x76, 0x7a, 0xca, 0x80, 0xb5,
	0xc0, 0xa2, 0x60, 0xbd, 0xf6, 0x88, 0x60, 0x66, 0x60, 0xee, 0x9c, 0xef, 0x60, 0x4f, 0x4f, 0x6a,
	0x0b, 0x2d, 0xf7, 0xe0, 0x43, 0x82, 0x99, 0xbb, 0x20, 0x58, 0x4f, 0x7e, 0xc0, 0x47, 0x60, 0x49,
	0x56, 0xed, 0xd3, 0x50, 0x1c, 0x99, 0x27, 0x72, 0xf7, 0xdc, 0x65, 0x17, 0x5b, 0xee, 0xc1, 0x07,
	0xb2, 0x82, 0x2b, 0x11, 0xd5, 0x17, 0x2a, 0x1b, 0x89, 0x79, 0x80, 0x19, 0xee, 0x8f, 0x17, 0x78,
	0x68, 0x9e, 0x78, 0x3c, 0x6a, 0xd6, 0xf6, 0x36, 0x28, 0x46, 0x6a, 0x44, 0xad, 0xac, 0xb4, 0x57,
	0xcd, 0x7a, 0x43, 0x3a, 0xcf, 0xbc, 0x18, 0x93, 0x83, 0x3e, 0x31, 0xc7, 0xda, 0x1c, 0xb0, 0xb0,
	0x85, 0x87, 0xef, 0x0e, 0x49, 0x3f, 0x92, 0x6a, 0x7d, 0x10, 0xf0, 0xf8, 0xe1, 0xc0, 0xf7, 0x00,
	0x48, 0x64, 0x5c, 0x2d, 0xb4, 0xb4, 0xb7, 0x3e, 0x71, 0x19, 0xb5, 0xb1, 0x24, 0x8d, 0xfc, 0x58,
	0x90, 0xdd, 0x54, 0xa6, 0xbc, 0xf3, 0xd7, 0x66, 0x34, 0x33, 0xeb, 0xb9, 0x0a, 0x96, 0x70, 0xb7,
	0xcb, 0x08, 0xe7, 0x44, 0xdf, 0xfc, 0x25, 0x37, 0x19, 0x80, 0xf7, 0xa7, 0xb0, 0xdc, 0x9c, 0xcb,
	0xa2, 0x4b, 0xa7, 0x61, 0xf6, 0x7e, 0x29, 0x81, 0xcb, 0x0a, 0x06, 0x7e, 0x67, 0x81, 0x05, 0xe3,
	0x17, 0x70, 0x73, 0x9e, 0x00, 0xa5, 0xcc, 0xa6, 0xb2, 0x95, 0x2f, 0x58, 0x37, 0x47, 0x8d, 0x2f,
	0x7f, 0xff, 0xe7, 0xe9, 0x25, 0x04, 0xeb, 0x4e, 0x96, 0x03, 0x1a, 0x83, 0x82, 0x4f, 0x2d, 0x50,
	0xd4, 0x5a, 0x07, 0x37, 0x72, 0x08, 0x62, 0x8c, 0xb3, 0x99, 0x2b, 0xd6, 0xd0, 0xec, 0x28, 0x9a,
	0x0d, 0xd8, 0x98, 0x45, 0x23, 0x95, 0xd9, 0xf9, 0x5c, 0xb9, 0xc1, 0x17, 0xf1, 0x36, 0x49, 0x99,
	0x85, 0x9b, 0xf9, 0x74, 0x3a, 0xe7, 0x36, 0xa5, 0x45, 0x3d, 0xdf, 0x36, 0x49, 0x30, 0xf8, 0x93,
	0x05, 0x96, 0xd3, 0x5a, 0x0e, 0x67, 0xbb, 0xc7, 0x14, 0x4b, 0xa8, 0xec, 0x9e, 0x23, 0xc3, 0xf0,
	0x6d, 0x2b, 0xbe, 0x9b, 0xf0, 0x46, 0x16, 0xdf, 0x84, 0x8d, 0xc0, 0x5f, 0x2d, 0xb0, 0x32, 0x45,
	0x32, 0xe1, 0xed, 0x99, 0x9d, 0xb3, 0x85, 0xb8, 0xf2, 0xd6, 0xf9, 0x13, 0x0d, 0xf9, 0x2d, 0x45,
	0x6e, 0xc3, 0xad, 0x2c, 0xf2, 0x69, 0xda, 0x0d, 0x7f, 0xb4, 0x40, 0x29, 0xe5, 0x51, 0xd0, 0x99,
	0x77, 0x9a, 0x2f, 0x02, 0xef, 0xe4, 0x4f, 0x30, 0xa0, 0x5b, 0x0a, 0x74, 0x1d, 0x5e, 0x9f, 0x75,
	0x05, 0xc6, 0x80, 0x3f, 0x58, 0x00, 0x24, 0x92, 0x0f, 0xed, 0x99, 0xed, 0x5e, 0xb2, 0x8d, 0x8a,
	0x93, 0x3b, 0xde, 0xd0, 0x6d, 0x28, 0xba, 0xeb, 0x10, 0x65, 0xd1, 0x05, 0x09, 0xcc, 0x6f, 0x16,
	0x28, 0x4f, 0x13, 0x3b, 0x38, 0xfb, 0x14, 0x67, 0x88, 0x71, 0xe5, 0xce, 0x05, 0x32, 0x0d, 0xf9,
	0x6d, 0x45, 0xbe, 0x0b, 0x9d, 0x2c, 0xf2, 0xce, 0x80, 0x85, 0x6d, 0xb9, 0xb9, 0x24, 0xce, 0x6f,
	0xf7, 0x24, 0xed, 0x37, 0x16, 0x28, 0x6a, 0xf7, 0x98, 0x23, 0x48, 0x13, 0x86, 0x35, 0x47, 0x90,
	0x26, 0x6d, 0x0c, 0xad, 0x2b, 0xb8, 0x3a, 0xac, 0x66, 0xc1, 0x69, 0xc3, 0x6a, 0xbe, 0x7f, 0x7c,
	0x5a, 0xb5, 0x9e, 0x9f, 0x56, 0xad, 0xbf, 0x4f, 0xab, 0xd6, 0xf7, 0x67, 0xd5, 0xc2, 0xf3, 0xb3,
	0x6a, 0xe1, 0x8f, 0xb3, 0x6a, 0xe1, 0x23, 0x3b, 0xed, 0xb9, 0x3d, 0xcc, 0x79, 0xe0, 0x6d, 0xeb,
	0x5a, 0x1e, 0x65, 0xc4, 0x19, 0x26, 0x25, 0x95, 0xff, 0x76, 0x8a, 0xea, 0x97, 0xc4, 0x9b, 0xff,
	0x05, 0x00, 0x00, 0xff, 0xff, 0xcc, 0xe4, 0x0b, 0xdc, 0x2e, 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 {
	// TaxRate return the current tax rate
	TaxRate(ctx context.Context, in *QueryTaxRateRequest, opts ...grpc.CallOption) (*QueryTaxRateResponse, error)
	// TaxCap returns the tax cap of a denom
	TaxCap(ctx context.Context, in *QueryTaxCapRequest, opts ...grpc.CallOption) (*QueryTaxCapResponse, error)
	// TaxCaps returns the all tax caps
	TaxCaps(ctx context.Context, in *QueryTaxCapsRequest, opts ...grpc.CallOption) (*QueryTaxCapsResponse, error)
	// RewardWeight return the current reward weight
	RewardWeight(ctx context.Context, in *QueryRewardWeightRequest, opts ...grpc.CallOption) (*QueryRewardWeightResponse, error)
	// SeigniorageProceeds return the current seigniorage proceeds
	SeigniorageProceeds(ctx context.Context, in *QuerySeigniorageProceedsRequest, opts ...grpc.CallOption) (*QuerySeigniorageProceedsResponse, error)
	// TaxProceeds return the current tax proceeds
	TaxProceeds(ctx context.Context, in *QueryTaxProceedsRequest, opts ...grpc.CallOption) (*QueryTaxProceedsResponse, error)
	// Indicators return the current trl informations
	Indicators(ctx context.Context, in *QueryIndicatorsRequest, opts ...grpc.CallOption) (*QueryIndicatorsResponse, error)
	// BurnTaxExemptionList returns all registered burn tax exemption addresses
	BurnTaxExemptionList(ctx context.Context, in *QueryBurnTaxExemptionListRequest, opts ...grpc.CallOption) (*QueryBurnTaxExemptionListResponse, error)
	// Params queries all parameters.
	Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error)
}

type queryClient struct {
	cc grpc1.ClientConn
}

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

func (c *queryClient) TaxRate(ctx context.Context, in *QueryTaxRateRequest, opts ...grpc.CallOption) (*QueryTaxRateResponse, error) {
	out := new(QueryTaxRateResponse)
	err := c.cc.Invoke(ctx, "/terra.treasury.v1beta1.Query/TaxRate", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) TaxCap(ctx context.Context, in *QueryTaxCapRequest, opts ...grpc.CallOption) (*QueryTaxCapResponse, error) {
	out := new(QueryTaxCapResponse)
	err := c.cc.Invoke(ctx, "/terra.treasury.v1beta1.Query/TaxCap", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) TaxCaps(ctx context.Context, in *QueryTaxCapsRequest, opts ...grpc.CallOption) (*QueryTaxCapsResponse, error) {
	out := new(QueryTaxCapsResponse)
	err := c.cc.Invoke(ctx, "/terra.treasury.v1beta1.Query/TaxCaps", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) RewardWeight(ctx context.Context, in *QueryRewardWeightRequest, opts ...grpc.CallOption) (*QueryRewardWeightResponse, error) {
	out := new(QueryRewardWeightResponse)
	err := c.cc.Invoke(ctx, "/terra.treasury.v1beta1.Query/RewardWeight", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) SeigniorageProceeds(ctx context.Context, in *QuerySeigniorageProceedsRequest, opts ...grpc.CallOption) (*QuerySeigniorageProceedsResponse, error) {
	out := new(QuerySeigniorageProceedsResponse)
	err := c.cc.Invoke(ctx, "/terra.treasury.v1beta1.Query/SeigniorageProceeds", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) TaxProceeds(ctx context.Context, in *QueryTaxProceedsRequest, opts ...grpc.CallOption) (*QueryTaxProceedsResponse, error) {
	out := new(QueryTaxProceedsResponse)
	err := c.cc.Invoke(ctx, "/terra.treasury.v1beta1.Query/TaxProceeds", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) Indicators(ctx context.Context, in *QueryIndicatorsRequest, opts ...grpc.CallOption) (*QueryIndicatorsResponse, error) {
	out := new(QueryIndicatorsResponse)
	err := c.cc.Invoke(ctx, "/terra.treasury.v1beta1.Query/Indicators", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) BurnTaxExemptionList(ctx context.Context, in *QueryBurnTaxExemptionListRequest, opts ...grpc.CallOption) (*QueryBurnTaxExemptionListResponse, error) {
	out := new(QueryBurnTaxExemptionListResponse)
	err := c.cc.Invoke(ctx, "/terra.treasury.v1beta1.Query/BurnTaxExemptionList", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

// QueryServer is the server API for Query service.
type QueryServer interface {
	// TaxRate return the current tax rate
	TaxRate(context.Context, *QueryTaxRateRequest) (*QueryTaxRateResponse, error)
	// TaxCap returns the tax cap of a denom
	TaxCap(context.Context, *QueryTaxCapRequest) (*QueryTaxCapResponse, error)
	// TaxCaps returns the all tax caps
	TaxCaps(context.Context, *QueryTaxCapsRequest) (*QueryTaxCapsResponse, error)
	// RewardWeight return the current reward weight
	RewardWeight(context.Context, *QueryRewardWeightRequest) (*QueryRewardWeightResponse, error)
	// SeigniorageProceeds return the current seigniorage proceeds
	SeigniorageProceeds(context.Context, *QuerySeigniorageProceedsRequest) (*QuerySeigniorageProceedsResponse, error)
	// TaxProceeds return the current tax proceeds
	TaxProceeds(context.Context, *QueryTaxProceedsRequest) (*QueryTaxProceedsResponse, error)
	// Indicators return the current trl informations
	Indicators(context.Context, *QueryIndicatorsRequest) (*QueryIndicatorsResponse, error)
	// BurnTaxExemptionList returns all registered burn tax exemption addresses
	BurnTaxExemptionList(context.Context, *QueryBurnTaxExemptionListRequest) (*QueryBurnTaxExemptionListResponse, error)
	// Params queries all parameters.
	Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error)
}

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

func (*UnimplementedQueryServer) TaxRate(ctx context.Context, req *QueryTaxRateRequest) (*QueryTaxRateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TaxRate not implemented")
}
func (*UnimplementedQueryServer) TaxCap(ctx context.Context, req *QueryTaxCapRequest) (*QueryTaxCapResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TaxCap not implemented")
}
func (*UnimplementedQueryServer) TaxCaps(ctx context.Context, req *QueryTaxCapsRequest) (*QueryTaxCapsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TaxCaps not implemented")
}
func (*UnimplementedQueryServer) RewardWeight(ctx context.Context, req *QueryRewardWeightRequest) (*QueryRewardWeightResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RewardWeight not implemented")
}
func (*UnimplementedQueryServer) SeigniorageProceeds(ctx context.Context, req *QuerySeigniorageProceedsRequest) (*QuerySeigniorageProceedsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SeigniorageProceeds not implemented")
}
func (*UnimplementedQueryServer) TaxProceeds(ctx context.Context, req *QueryTaxProceedsRequest) (*QueryTaxProceedsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TaxProceeds not implemented")
}
func (*UnimplementedQueryServer) Indicators(ctx context.Context, req *QueryIndicatorsRequest) (*QueryIndicatorsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Indicators not implemented")
}
func (*UnimplementedQueryServer) BurnTaxExemptionList(ctx context.Context, req *QueryBurnTaxExemptionListRequest) (*QueryBurnTaxExemptionListResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BurnTaxExemptionList not implemented")
}
func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Params not implemented")
}

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

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

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

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

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

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

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

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

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

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

var _Query_serviceDesc = grpc.ServiceDesc{
	ServiceName: "terra.treasury.v1beta1.Query",
	HandlerType: (*QueryServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "TaxRate",
			Handler:    _Query_TaxRate_Handler,
		},
		{
			MethodName: "TaxCap",
			Handler:    _Query_TaxCap_Handler,
		},
		{
			MethodName: "TaxCaps",
			Handler:    _Query_TaxCaps_Handler,
		},
		{
			MethodName: "RewardWeight",
			Handler:    _Query_RewardWeight_Handler,
		},
		{
			MethodName: "SeigniorageProceeds",
			Handler:    _Query_SeigniorageProceeds_Handler,
		},
		{
			MethodName: "TaxProceeds",
			Handler:    _Query_TaxProceeds_Handler,
		},
		{
			MethodName: "Indicators",
			Handler:    _Query_Indicators_Handler,
		},
		{
			MethodName: "BurnTaxExemptionList",
			Handler:    _Query_BurnTaxExemptionList_Handler,
		},
		{
			MethodName: "Params",
			Handler:    _Query_Params_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "terra/treasury/v1beta1/query.proto",
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *QueryParamsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryParamsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *QueryParamsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryParamsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *QueryBurnTaxExemptionListRequest) 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
	}
	return len(dAtA) - i, nil
}

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

func (m *QueryBurnTaxExemptionListResponse) 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.Addresses) > 0 {
		for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Addresses[iNdEx])
			copy(dAtA[i:], m.Addresses[iNdEx])
			i = encodeVarintQuery(dAtA, i, uint64(len(m.Addresses[iNdEx])))
			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 *QueryTaxRateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *QueryBurnTaxExemptionListRequest) 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 *QueryBurnTaxExemptionListResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Addresses) > 0 {
		for _, s := range m.Addresses {
			l = len(s)
			n += 1 + l + sovQuery(uint64(l))
		}
	}
	if m.Pagination != nil {
		l = m.Pagination.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 *QueryTaxRateRequest) 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: QueryTaxRateRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryTaxRateRequest: 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 *QueryTaxRateResponse) 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: QueryTaxRateResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryTaxRateResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TaxRate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TaxRate.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 *QueryTaxCapRequest) 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: QueryTaxCapRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryTaxCapRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Denom", 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.Denom = 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 *QueryTaxCapResponse) 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: QueryTaxCapResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryTaxCapResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TaxCap", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TaxCap.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 *QueryTaxCapsRequest) 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: QueryTaxCapsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryTaxCapsRequest: 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 *QueryTaxCapsResponseItem) 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: QueryTaxCapsResponseItem: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryTaxCapsResponseItem: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Denom", 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.Denom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TaxCap", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TaxCap.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 *QueryTaxCapsResponse) 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: QueryTaxCapsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryTaxCapsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TaxCaps", 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.TaxCaps = append(m.TaxCaps, QueryTaxCapsResponseItem{})
			if err := m.TaxCaps[len(m.TaxCaps)-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 *QueryRewardWeightRequest) 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: QueryRewardWeightRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryRewardWeightRequest: 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 *QueryRewardWeightResponse) 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: QueryRewardWeightResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryRewardWeightResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RewardWeight", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.RewardWeight.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 *QueryTaxProceedsRequest) 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: QueryTaxProceedsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryTaxProceedsRequest: 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 *QueryTaxProceedsResponse) 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: QueryTaxProceedsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryTaxProceedsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TaxProceeds", 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.TaxProceeds = append(m.TaxProceeds, types.Coin{})
			if err := m.TaxProceeds[len(m.TaxProceeds)-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 *QuerySeigniorageProceedsRequest) 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: QuerySeigniorageProceedsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QuerySeigniorageProceedsRequest: 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 *QuerySeigniorageProceedsResponse) 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: QuerySeigniorageProceedsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QuerySeigniorageProceedsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SeigniorageProceeds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.SeigniorageProceeds.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 *QueryIndicatorsRequest) 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: QueryIndicatorsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryIndicatorsRequest: 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 *QueryIndicatorsResponse) 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: QueryIndicatorsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryIndicatorsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TRLYear", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TRLYear.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TRLMonth", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TRLMonth.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 *QueryParamsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryParamsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryParamsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func 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")
)