query.pb.go

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

package types

import (
	context "context"
	fmt "fmt"
	query "github.com/cosmos/cosmos-sdk/types/query"
	_ "github.com/cosmos/gogoproto/gogoproto"
	grpc1 "github.com/cosmos/gogoproto/grpc"
	proto "github.com/cosmos/gogoproto/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

// QueryFeePayContract retrieves a single fee pay contract
type QueryFeePayContract struct {
	// contract_address defines the address of the fee pay contract
	ContractAddress string `protobuf:"bytes,1,opt,name=contract_address,json=contractAddress,proto3" json:"contract_address,omitempty"`
}

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

var xxx_messageInfo_QueryFeePayContract proto.InternalMessageInfo

func (m *QueryFeePayContract) GetContractAddress() string {
	if m != nil {
		return m.ContractAddress
	}
	return ""
}

// QueryFeePayContractResponse defines the response for retrieving a single fee pay contract
type QueryFeePayContractResponse struct {
	// contract defines the fee pay contract
	FeePayContract *FeePayContract `protobuf:"bytes,1,opt,name=fee_pay_contract,json=feePayContract,proto3" json:"fee_pay_contract,omitempty"`
}

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

var xxx_messageInfo_QueryFeePayContractResponse proto.InternalMessageInfo

func (m *QueryFeePayContractResponse) GetFeePayContract() *FeePayContract {
	if m != nil {
		return m.FeePayContract
	}
	return nil
}

// Message for querying a list of fee pay contracts
type QueryFeePayContracts struct {
	// Pagination defines an optional pagination for the request.
	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryFeePayContracts proto.InternalMessageInfo

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

// The response for querying all fee pay contracts
type QueryFeePayContractsResponse struct {
	// A slice of all the stored fee pay contracts
	FeePayContracts []FeePayContract `protobuf:"bytes,1,rep,name=fee_pay_contracts,json=feePayContracts,proto3" json:"fee_pay_contracts"`
	// pagination defines the pagination in the response.
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryFeePayContractsResponse proto.InternalMessageInfo

func (m *QueryFeePayContractsResponse) GetFeePayContracts() []FeePayContract {
	if m != nil {
		return m.FeePayContracts
	}
	return nil
}

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

// Message for querying the number of uses on a fee pay contract by wallet
type QueryFeePayContractUses struct {
	// The contract address.
	ContractAddress string `protobuf:"bytes,1,opt,name=contract_address,json=contractAddress,proto3" json:"contract_address,omitempty"`
	// The wallet address.
	WalletAddress string `protobuf:"bytes,2,opt,name=wallet_address,json=walletAddress,proto3" json:"wallet_address,omitempty"`
}

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

var xxx_messageInfo_QueryFeePayContractUses proto.InternalMessageInfo

func (m *QueryFeePayContractUses) GetContractAddress() string {
	if m != nil {
		return m.ContractAddress
	}
	return ""
}

func (m *QueryFeePayContractUses) GetWalletAddress() string {
	if m != nil {
		return m.WalletAddress
	}
	return ""
}

// The response for querying the number of uses on a fee pay contract by wallet
type QueryFeePayContractUsesResponse struct {
	// The number of uses on the fee pay contract by wallet
	Uses uint64 `protobuf:"varint,1,opt,name=uses,proto3" json:"uses,omitempty"`
}

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

var xxx_messageInfo_QueryFeePayContractUsesResponse proto.InternalMessageInfo

func (m *QueryFeePayContractUsesResponse) GetUses() uint64 {
	if m != nil {
		return m.Uses
	}
	return 0
}

// Message for querying if a wallet is eligible for fee pay contract interactions
type QueryFeePayWalletIsEligible struct {
	// The contract address.
	ContractAddress string `protobuf:"bytes,1,opt,name=contract_address,json=contractAddress,proto3" json:"contract_address,omitempty"`
	// The wallet address.
	WalletAddress string `protobuf:"bytes,2,opt,name=wallet_address,json=walletAddress,proto3" json:"wallet_address,omitempty"`
}

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

var xxx_messageInfo_QueryFeePayWalletIsEligible proto.InternalMessageInfo

func (m *QueryFeePayWalletIsEligible) GetContractAddress() string {
	if m != nil {
		return m.ContractAddress
	}
	return ""
}

func (m *QueryFeePayWalletIsEligible) GetWalletAddress() string {
	if m != nil {
		return m.WalletAddress
	}
	return ""
}

// The response for querying if a wallet is eligible for fee pay contract interactions
type QueryFeePayWalletIsEligibleResponse struct {
	// The eligibility of the wallet for fee pay contract interactions
	Eligible bool `protobuf:"varint,1,opt,name=eligible,proto3" json:"eligible,omitempty"`
}

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

var xxx_messageInfo_QueryFeePayWalletIsEligibleResponse proto.InternalMessageInfo

func (m *QueryFeePayWalletIsEligibleResponse) GetEligible() bool {
	if m != nil {
		return m.Eligible
	}
	return false
}

// 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_d6539df905bf35ca, []int{8}
}
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 is the returned Feepay parameter
	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_d6539df905bf35ca, []int{9}
}
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{}
}

func init() {
	proto.RegisterType((*QueryFeePayContract)(nil), "furya.feepay.v1.QueryFeePayContract")
	proto.RegisterType((*QueryFeePayContractResponse)(nil), "furya.feepay.v1.QueryFeePayContractResponse")
	proto.RegisterType((*QueryFeePayContracts)(nil), "furya.feepay.v1.QueryFeePayContracts")
	proto.RegisterType((*QueryFeePayContractsResponse)(nil), "furya.feepay.v1.QueryFeePayContractsResponse")
	proto.RegisterType((*QueryFeePayContractUses)(nil), "furya.feepay.v1.QueryFeePayContractUses")
	proto.RegisterType((*QueryFeePayContractUsesResponse)(nil), "furya.feepay.v1.QueryFeePayContractUsesResponse")
	proto.RegisterType((*QueryFeePayWalletIsEligible)(nil), "furya.feepay.v1.QueryFeePayWalletIsEligible")
	proto.RegisterType((*QueryFeePayWalletIsEligibleResponse)(nil), "furya.feepay.v1.QueryFeePayWalletIsEligibleResponse")
	proto.RegisterType((*QueryParamsRequest)(nil), "furya.feepay.v1.QueryParamsRequest")
	proto.RegisterType((*QueryParamsResponse)(nil), "furya.feepay.v1.QueryParamsResponse")
}

func init() { proto.RegisterFile("furya/feepay/v1/query.proto", fileDescriptor_d6539df905bf35ca) }

var fileDescriptor_d6539df905bf35ca = []byte{
	// 680 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x55, 0x4f, 0x4f, 0xd4, 0x40,
	0x14, 0xdf, 0x22, 0x6e, 0x70, 0x8c, 0x0b, 0x8e, 0x04, 0x49, 0xc1, 0x62, 0x8a, 0x88, 0x8a, 0x76,
	0xb2, 0xa0, 0x77, 0x81, 0xf0, 0x2f, 0xc6, 0x64, 0x6d, 0x62, 0x4c, 0x3c, 0x48, 0x66, 0x97, 0xb7,
	0xb5, 0x5a, 0x3a, 0x65, 0xa7, 0x8b, 0x6e, 0x08, 0x17, 0xcf, 0x1e, 0x4c, 0x3c, 0xf8, 0x21, 0xfc,
	0x04, 0x7c, 0x03, 0xbc, 0x91, 0x78, 0xf1, 0x64, 0x0c, 0xf8, 0x41, 0x4c, 0x67, 0xa6, 0xc5, 0x8e,
	0x65, 0xd9, 0x3d, 0x78, 0x9b, 0x7d, 0xf3, 0x9b, 0xdf, 0xfb, 0xbd, 0xf7, 0x7e, 0xaf, 0x8b, 0xcc,
	0x37, 0xed, 0x90, 0x91, 0x26, 0x40, 0x44, 0x3b, 0x64, 0xb7, 0x4a, 0x76, 0xda, 0xd0, 0xea, 0x38,
	0x51, 0x8b, 0xc5, 0x0c, 0x57, 0x92, 0x3b, 0x47, 0xde, 0x39, 0xbb, 0x55, 0xf3, 0x5e, 0x83, 0xf1,
	0x6d, 0xc6, 0x49, 0x9d, 0x72, 0x90, 0x40, 0xb2, 0x5b, 0xad, 0x43, 0x4c, 0xab, 0x24, 0xa2, 0x9e,
	0x1f, 0xd2, 0xd8, 0x67, 0xa1, 0x7c, 0x6b, 0x4e, 0x6a, 0xbc, 0x1e, 0x84, 0xc0, 0x7d, 0xae, 0x6e,
	0x27, 0xb4, 0x5b, 0x95, 0x43, 0x5e, 0x8e, 0x7a, 0xcc, 0x63, 0xe2, 0x48, 0x92, 0x53, 0x4a, 0xe8,
	0x31, 0xe6, 0x05, 0x40, 0x68, 0xe4, 0x13, 0x1a, 0x86, 0x2c, 0x16, 0xd9, 0x14, 0xa1, 0xfd, 0x18,
	0x5d, 0x7b, 0x96, 0x08, 0x5a, 0x05, 0xa8, 0xd1, 0xce, 0x32, 0x0b, 0xe3, 0x16, 0x6d, 0xc4, 0xf8,
	0x2e, 0x1a, 0x69, 0xa8, 0xf3, 0x26, 0xdd, 0xda, 0x6a, 0x01, 0xe7, 0xe3, 0xc6, 0x4d, 0xe3, 0xce,
	0x25, 0x77, 0x38, 0x8d, 0x2f, 0xca, 0xb0, 0xed, 0xa1, 0x89, 0x02, 0x06, 0x17, 0x78, 0xc4, 0x42,
	0x0e, 0x78, 0x1d, 0x8d, 0x34, 0x01, 0x36, 0x23, 0xda, 0xd9, 0x4c, 0x5f, 0x0a, 0xa6, 0xcb, 0xf3,
	0x96, 0x93, 0x6f, 0x93, 0xa3, 0x31, 0x54, 0x9a, 0xb9, 0xdf, 0xf6, 0x2b, 0x34, 0x5a, 0x90, 0x88,
	0xe3, 0x55, 0x84, 0x4e, 0xbb, 0xa8, 0xb8, 0x6f, 0x3b, 0xb2, 0xe5, 0x4e, 0xd2, 0x72, 0x47, 0xce,
	0x46, 0xb5, 0xdc, 0xa9, 0x51, 0x0f, 0x5c, 0xd8, 0x69, 0x03, 0x8f, 0xdd, 0xbf, 0x5e, 0xda, 0x07,
	0x06, 0x9a, 0x2c, 0x4a, 0x90, 0x95, 0x52, 0x43, 0x57, 0xf5, 0x52, 0x92, 0xae, 0x5c, 0x38, 0xbf,
	0x96, 0xa5, 0xc1, 0xc3, 0x9f, 0x53, 0x25, 0x77, 0xb8, 0xa9, 0x49, 0x5f, 0xcb, 0x49, 0x1f, 0x10,
	0xd2, 0x67, 0xcf, 0x95, 0x2e, 0xe5, 0xe4, 0xb4, 0xbf, 0x45, 0xd7, 0x0b, 0xa4, 0x3f, 0xe7, 0xc0,
	0xfb, 0x18, 0x25, 0x9e, 0x41, 0x95, 0x77, 0x34, 0x08, 0xe0, 0x14, 0x38, 0x20, 0x80, 0x57, 0x64,
	0x34, 0x9d, 0xf8, 0x23, 0x34, 0x75, 0x46, 0xb2, 0xac, 0x55, 0x18, 0x0d, 0xb6, 0x39, 0xc8, 0x44,
	0x83, 0xae, 0x38, 0xdb, 0x2c, 0x67, 0x94, 0x17, 0x82, 0x72, 0x83, 0xaf, 0x04, 0xbe, 0xe7, 0xd7,
	0x03, 0xf8, 0x0f, 0x3a, 0x17, 0xd1, 0x74, 0x97, 0x84, 0x99, 0x56, 0x13, 0x0d, 0x81, 0x8a, 0x89,
	0x84, 0x43, 0x6e, 0xf6, 0xdb, 0x1e, 0x45, 0x58, 0x50, 0xd4, 0x68, 0x8b, 0x6e, 0x73, 0xe5, 0x1a,
	0xfb, 0x89, 0x5a, 0x9a, 0x34, 0xaa, 0x88, 0x1e, 0xa2, 0x72, 0x24, 0x22, 0xca, 0x84, 0x63, 0xba,
	0x29, 0x24, 0x5e, 0x99, 0x41, 0x61, 0xe7, 0xbf, 0x96, 0xd1, 0x45, 0xc1, 0x86, 0xbf, 0x18, 0xa8,
	0xa2, 0xed, 0xe1, 0xb4, 0x4e, 0x51, 0xd0, 0x78, 0x73, 0xae, 0x07, 0x50, 0x2a, 0xd2, 0x5e, 0xf8,
	0xf0, 0xfd, 0xf7, 0xe7, 0x81, 0x07, 0x78, 0x8e, 0x68, 0x9f, 0x92, 0xb4, 0xc9, 0x64, 0x4f, 0x1f,
	0xc3, 0x3e, 0xfe, 0x68, 0xa0, 0x61, 0x7d, 0xed, 0x6e, 0xf5, 0x90, 0x95, 0x9b, 0xf7, 0x7b, 0x41,
	0x65, 0xe2, 0x66, 0x84, 0xb8, 0x29, 0x7c, 0x43, 0x17, 0x47, 0x83, 0xe0, 0x74, 0xe7, 0xf0, 0x81,
	0x81, 0x70, 0x81, 0xd3, 0x67, 0x7b, 0xc8, 0x95, 0x00, 0x4d, 0xd2, 0x23, 0x30, 0xd3, 0xb5, 0x21,
	0x74, 0x2d, 0xe3, 0xc5, 0x3e, 0x9a, 0x46, 0x12, 0xd3, 0x93, 0xbd, 0xbc, 0x51, 0xf7, 0xf1, 0x37,
	0x03, 0x8d, 0x9d, 0xb1, 0x01, 0xdd, 0xe6, 0xa8, 0x83, 0xcd, 0x85, 0x3e, 0xc0, 0x59, 0x1d, 0x4f,
	0x45, 0x1d, 0x6b, 0x78, 0xa5, 0x9f, 0x3a, 0xd2, 0x65, 0xf8, 0xb7, 0x96, 0x1d, 0x54, 0x96, 0x96,
	0xc6, 0x76, 0xa1, 0x9a, 0xdc, 0xd6, 0x98, 0xd3, 0x5d, 0x31, 0x4a, 0xa1, 0x25, 0x14, 0x8e, 0xe3,
	0x31, 0x5d, 0xa1, 0xdc, 0x96, 0xa5, 0xf5, 0xc3, 0x63, 0xcb, 0x38, 0x3a, 0xb6, 0x8c, 0x5f, 0xc7,
	0x96, 0xf1, 0xe9, 0xc4, 0x2a, 0x1d, 0x9d, 0x58, 0xa5, 0x1f, 0x27, 0x56, 0xe9, 0xa5, 0xe3, 0xf9,
	0xf1, 0xeb, 0x76, 0xdd, 0x69, 0xb0, 0x6d, 0xb2, 0x2c, 0xbe, 0xa0, 0x99, 0xbf, 0x24, 0xd7, 0xfb,
	0x94, 0x2d, 0xee, 0x44, 0xc0, 0xeb, 0x65, 0xf1, 0x07, 0xb8, 0xf0, 0x27, 0x00, 0x00, 0xff, 0xff,
	0x44, 0xa8, 0x44, 0xd2, 0xc9, 0x07, 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 {
	// FeePayContract queries a single fee pay contract by address
	FeePayContract(ctx context.Context, in *QueryFeePayContract, opts ...grpc.CallOption) (*QueryFeePayContractResponse, error)
	// Retrieve all fee pay contracts
	FeePayContracts(ctx context.Context, in *QueryFeePayContracts, opts ...grpc.CallOption) (*QueryFeePayContractsResponse, error)
	// Retrieve the number of uses on a fee pay contract by wallet
	FeePayContractUses(ctx context.Context, in *QueryFeePayContractUses, opts ...grpc.CallOption) (*QueryFeePayContractUsesResponse, error)
	// Query if sender is eligible for fee pay contract interaction
	FeePayWalletIsEligible(ctx context.Context, in *QueryFeePayWalletIsEligible, opts ...grpc.CallOption) (*QueryFeePayWalletIsEligibleResponse, error)
	// Params retrieves the FeePay module params
	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) FeePayContract(ctx context.Context, in *QueryFeePayContract, opts ...grpc.CallOption) (*QueryFeePayContractResponse, error) {
	out := new(QueryFeePayContractResponse)
	err := c.cc.Invoke(ctx, "/furya.feepay.v1.Query/FeePayContract", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) FeePayContracts(ctx context.Context, in *QueryFeePayContracts, opts ...grpc.CallOption) (*QueryFeePayContractsResponse, error) {
	out := new(QueryFeePayContractsResponse)
	err := c.cc.Invoke(ctx, "/furya.feepay.v1.Query/FeePayContracts", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) FeePayContractUses(ctx context.Context, in *QueryFeePayContractUses, opts ...grpc.CallOption) (*QueryFeePayContractUsesResponse, error) {
	out := new(QueryFeePayContractUsesResponse)
	err := c.cc.Invoke(ctx, "/furya.feepay.v1.Query/FeePayContractUses", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) FeePayWalletIsEligible(ctx context.Context, in *QueryFeePayWalletIsEligible, opts ...grpc.CallOption) (*QueryFeePayWalletIsEligibleResponse, error) {
	out := new(QueryFeePayWalletIsEligibleResponse)
	err := c.cc.Invoke(ctx, "/furya.feepay.v1.Query/FeePayWalletIsEligible", 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, "/furya.feepay.v1.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 {
	// FeePayContract queries a single fee pay contract by address
	FeePayContract(context.Context, *QueryFeePayContract) (*QueryFeePayContractResponse, error)
	// Retrieve all fee pay contracts
	FeePayContracts(context.Context, *QueryFeePayContracts) (*QueryFeePayContractsResponse, error)
	// Retrieve the number of uses on a fee pay contract by wallet
	FeePayContractUses(context.Context, *QueryFeePayContractUses) (*QueryFeePayContractUsesResponse, error)
	// Query if sender is eligible for fee pay contract interaction
	FeePayWalletIsEligible(context.Context, *QueryFeePayWalletIsEligible) (*QueryFeePayWalletIsEligibleResponse, error)
	// Params retrieves the FeePay module params
	Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error)
}

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

func (*UnimplementedQueryServer) FeePayContract(ctx context.Context, req *QueryFeePayContract) (*QueryFeePayContractResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method FeePayContract not implemented")
}
func (*UnimplementedQueryServer) FeePayContracts(ctx context.Context, req *QueryFeePayContracts) (*QueryFeePayContractsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method FeePayContracts not implemented")
}
func (*UnimplementedQueryServer) FeePayContractUses(ctx context.Context, req *QueryFeePayContractUses) (*QueryFeePayContractUsesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method FeePayContractUses not implemented")
}
func (*UnimplementedQueryServer) FeePayWalletIsEligible(ctx context.Context, req *QueryFeePayWalletIsEligible) (*QueryFeePayWalletIsEligibleResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method FeePayWalletIsEligible 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_FeePayContract_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryFeePayContract)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).FeePayContract(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/furya.feepay.v1.Query/FeePayContract",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).FeePayContract(ctx, req.(*QueryFeePayContract))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_FeePayContracts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryFeePayContracts)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).FeePayContracts(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/furya.feepay.v1.Query/FeePayContracts",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).FeePayContracts(ctx, req.(*QueryFeePayContracts))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_FeePayContractUses_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryFeePayContractUses)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).FeePayContractUses(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/furya.feepay.v1.Query/FeePayContractUses",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).FeePayContractUses(ctx, req.(*QueryFeePayContractUses))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_FeePayWalletIsEligible_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryFeePayWalletIsEligible)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).FeePayWalletIsEligible(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/furya.feepay.v1.Query/FeePayWalletIsEligible",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).FeePayWalletIsEligible(ctx, req.(*QueryFeePayWalletIsEligible))
	}
	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: "/furya.feepay.v1.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: "furya.feepay.v1.Query",
	HandlerType: (*QueryServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "FeePayContract",
			Handler:    _Query_FeePayContract_Handler,
		},
		{
			MethodName: "FeePayContracts",
			Handler:    _Query_FeePayContracts_Handler,
		},
		{
			MethodName: "FeePayContractUses",
			Handler:    _Query_FeePayContractUses_Handler,
		},
		{
			MethodName: "FeePayWalletIsEligible",
			Handler:    _Query_FeePayWalletIsEligible_Handler,
		},
		{
			MethodName: "Params",
			Handler:    _Query_Params_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "furya/feepay/v1/query.proto",
}

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

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

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

func (m *QueryFeePayContractResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.FeePayContract != nil {
		{
			size, err := m.FeePayContract.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 *QueryFeePayContracts) 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 *QueryFeePayContracts) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

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

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

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

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

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

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

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

func (m *QueryFeePayWalletIsEligibleResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Eligible {
		i--
		if m.Eligible {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	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 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 *QueryFeePayContract) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContractAddress)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

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

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

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

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryFeePayWalletIsEligible) 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: QueryFeePayWalletIsEligible: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryFeePayWalletIsEligible: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContractAddress", 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.ContractAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WalletAddress", 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.WalletAddress = 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 *QueryFeePayWalletIsEligibleResponse) 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: QueryFeePayWalletIsEligibleResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryFeePayWalletIsEligibleResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Eligible", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Eligible = bool(v != 0)
		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 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")
)