query.pb.go

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

package types

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

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

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

// QueryParamsRequest defines the request type for querying x/bep3 parameters.
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_a5e4082d53c18bf6, []int{0}
}
func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryParamsRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryParamsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryParamsRequest.Merge(m, src)
}
func (m *QueryParamsRequest) XXX_Size() int {
	return m.Size()
}
func (m *QueryParamsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryParamsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryParamsRequest proto.InternalMessageInfo

// QueryParamsResponse defines the response type for querying x/bep3 parameters.
type QueryParamsResponse struct {
	// params represents 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_a5e4082d53c18bf6, []int{1}
}
func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryParamsResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryParamsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryParamsResponse.Merge(m, src)
}
func (m *QueryParamsResponse) XXX_Size() int {
	return m.Size()
}
func (m *QueryParamsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryParamsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryParamsResponse proto.InternalMessageInfo

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

// QueryAssetSupplyRequest is the request type for the Query/AssetSupply RPC method.
type QueryAssetSupplyRequest struct {
	// denom filters the asset response for the specified denom
	Denom string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"`
}

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

var xxx_messageInfo_QueryAssetSupplyRequest proto.InternalMessageInfo

// AssetSupplyResponse defines information about an asset's supply.
type AssetSupplyResponse struct {
	// incoming_supply represents the incoming supply of an asset
	IncomingSupply types.Coin `protobuf:"bytes,1,opt,name=incoming_supply,json=incomingSupply,proto3" json:"incoming_supply"`
	// outgoing_supply represents the outgoing supply of an asset
	OutgoingSupply types.Coin `protobuf:"bytes,2,opt,name=outgoing_supply,json=outgoingSupply,proto3" json:"outgoing_supply"`
	// current_supply represents the current on-chain supply of an asset
	CurrentSupply types.Coin `protobuf:"bytes,3,opt,name=current_supply,json=currentSupply,proto3" json:"current_supply"`
	// time_limited_current_supply represents the time limited current supply of an asset
	TimeLimitedCurrentSupply types.Coin `protobuf:"bytes,4,opt,name=time_limited_current_supply,json=timeLimitedCurrentSupply,proto3" json:"time_limited_current_supply"`
	// time_elapsed represents the time elapsed
	TimeElapsed time.Duration `protobuf:"bytes,5,opt,name=time_elapsed,json=timeElapsed,proto3,stdduration" json:"time_elapsed"`
}

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

var xxx_messageInfo_AssetSupplyResponse proto.InternalMessageInfo

func (m *AssetSupplyResponse) GetIncomingSupply() types.Coin {
	if m != nil {
		return m.IncomingSupply
	}
	return types.Coin{}
}

func (m *AssetSupplyResponse) GetOutgoingSupply() types.Coin {
	if m != nil {
		return m.OutgoingSupply
	}
	return types.Coin{}
}

func (m *AssetSupplyResponse) GetCurrentSupply() types.Coin {
	if m != nil {
		return m.CurrentSupply
	}
	return types.Coin{}
}

func (m *AssetSupplyResponse) GetTimeLimitedCurrentSupply() types.Coin {
	if m != nil {
		return m.TimeLimitedCurrentSupply
	}
	return types.Coin{}
}

func (m *AssetSupplyResponse) GetTimeElapsed() time.Duration {
	if m != nil {
		return m.TimeElapsed
	}
	return 0
}

// QueryAssetSupplyResponse is the response type for the Query/AssetSupply RPC method.
type QueryAssetSupplyResponse struct {
	// asset_supply represents the supply of the asset
	AssetSupply AssetSupplyResponse `protobuf:"bytes,1,opt,name=asset_supply,json=assetSupply,proto3" json:"asset_supply"`
}

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

var xxx_messageInfo_QueryAssetSupplyResponse proto.InternalMessageInfo

func (m *QueryAssetSupplyResponse) GetAssetSupply() AssetSupplyResponse {
	if m != nil {
		return m.AssetSupply
	}
	return AssetSupplyResponse{}
}

// QueryAssetSuppliesRequest is the request type for the Query/AssetSupplies RPC method.
type QueryAssetSuppliesRequest struct {
}

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

var xxx_messageInfo_QueryAssetSuppliesRequest proto.InternalMessageInfo

// QueryAssetSuppliesResponse is the response type for the Query/AssetSupplies RPC method.
type QueryAssetSuppliesResponse struct {
	// asset_supplies represents the supplies of returned assets
	AssetSupplies []AssetSupplyResponse `protobuf:"bytes,1,rep,name=asset_supplies,json=assetSupplies,proto3" json:"asset_supplies"`
}

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

var xxx_messageInfo_QueryAssetSuppliesResponse proto.InternalMessageInfo

func (m *QueryAssetSuppliesResponse) GetAssetSupplies() []AssetSupplyResponse {
	if m != nil {
		return m.AssetSupplies
	}
	return nil
}

// QueryAtomicSwapRequest is the request type for the Query/AtomicSwap RPC method.
type QueryAtomicSwapRequest struct {
	// swap_id represents the id of the swap to query
	SwapId string `protobuf:"bytes,1,opt,name=swap_id,json=swapId,proto3" json:"swap_id,omitempty"`
}

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

var xxx_messageInfo_QueryAtomicSwapRequest proto.InternalMessageInfo

// QueryAtomicSwapResponse is the response type for the Query/AtomicSwap RPC method.
type QueryAtomicSwapResponse struct {
	AtomicSwap AtomicSwapResponse `protobuf:"bytes,2,opt,name=atomic_swap,json=atomicSwap,proto3" json:"atomic_swap"`
}

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

var xxx_messageInfo_QueryAtomicSwapResponse proto.InternalMessageInfo

func (m *QueryAtomicSwapResponse) GetAtomicSwap() AtomicSwapResponse {
	if m != nil {
		return m.AtomicSwap
	}
	return AtomicSwapResponse{}
}

// AtomicSwapResponse represents the returned atomic swap properties
type AtomicSwapResponse struct {
	// id represents the id of the atomic swap
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// amount represents the amount being swapped
	Amount github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,2,rep,name=amount,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"amount"`
	// random_number_hash represents the hash of the random number
	RandomNumberHash string `protobuf:"bytes,3,opt,name=random_number_hash,json=randomNumberHash,proto3" json:"random_number_hash,omitempty"`
	// expire_height represents the height when the swap expires
	ExpireHeight uint64 `protobuf:"varint,4,opt,name=expire_height,json=expireHeight,proto3" json:"expire_height,omitempty"`
	// timestamp represents the timestamp of the swap
	Timestamp int64 `protobuf:"varint,5,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// sender is the fury chain sender of the swap
	Sender string `protobuf:"bytes,6,opt,name=sender,proto3" json:"sender,omitempty"`
	// recipient is the fury chain recipient of the swap
	Recipient string `protobuf:"bytes,7,opt,name=recipient,proto3" json:"recipient,omitempty"`
	// sender_other_chain is the sender on the other chain
	SenderOtherChain string `protobuf:"bytes,8,opt,name=sender_other_chain,json=senderOtherChain,proto3" json:"sender_other_chain,omitempty"`
	// recipient_other_chain is the recipient on the other chain
	RecipientOtherChain string `protobuf:"bytes,9,opt,name=recipient_other_chain,json=recipientOtherChain,proto3" json:"recipient_other_chain,omitempty"`
	// closed_block is the block when the swap is closed
	ClosedBlock int64 `protobuf:"varint,10,opt,name=closed_block,json=closedBlock,proto3" json:"closed_block,omitempty"`
	// status represents the current status of the swap
	Status SwapStatus `protobuf:"varint,11,opt,name=status,proto3,enum=fury.bep3.v1beta1.SwapStatus" json:"status,omitempty"`
	// cross_chain identifies whether the atomic swap is cross chain
	CrossChain bool `protobuf:"varint,12,opt,name=cross_chain,json=crossChain,proto3" json:"cross_chain,omitempty"`
	// direction identifies if the swap is incoming or outgoing
	Direction SwapDirection `protobuf:"varint,13,opt,name=direction,proto3,enum=fury.bep3.v1beta1.SwapDirection" json:"direction,omitempty"`
}

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

var xxx_messageInfo_AtomicSwapResponse proto.InternalMessageInfo

func (m *AtomicSwapResponse) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *AtomicSwapResponse) GetAmount() github_com_cosmos_cosmos_sdk_types.Coins {
	if m != nil {
		return m.Amount
	}
	return nil
}

func (m *AtomicSwapResponse) GetRandomNumberHash() string {
	if m != nil {
		return m.RandomNumberHash
	}
	return ""
}

func (m *AtomicSwapResponse) GetExpireHeight() uint64 {
	if m != nil {
		return m.ExpireHeight
	}
	return 0
}

func (m *AtomicSwapResponse) GetTimestamp() int64 {
	if m != nil {
		return m.Timestamp
	}
	return 0
}

func (m *AtomicSwapResponse) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *AtomicSwapResponse) GetRecipient() string {
	if m != nil {
		return m.Recipient
	}
	return ""
}

func (m *AtomicSwapResponse) GetSenderOtherChain() string {
	if m != nil {
		return m.SenderOtherChain
	}
	return ""
}

func (m *AtomicSwapResponse) GetRecipientOtherChain() string {
	if m != nil {
		return m.RecipientOtherChain
	}
	return ""
}

func (m *AtomicSwapResponse) GetClosedBlock() int64 {
	if m != nil {
		return m.ClosedBlock
	}
	return 0
}

func (m *AtomicSwapResponse) GetStatus() SwapStatus {
	if m != nil {
		return m.Status
	}
	return SWAP_STATUS_UNSPECIFIED
}

func (m *AtomicSwapResponse) GetCrossChain() bool {
	if m != nil {
		return m.CrossChain
	}
	return false
}

func (m *AtomicSwapResponse) GetDirection() SwapDirection {
	if m != nil {
		return m.Direction
	}
	return SWAP_DIRECTION_UNSPECIFIED
}

// QueryAtomicSwapsRequest is the request type for the Query/AtomicSwaps RPC method.
type QueryAtomicSwapsRequest struct {
	// involve filters by address
	Involve string `protobuf:"bytes,1,opt,name=involve,proto3" json:"involve,omitempty"`
	// expiration filters by expiration block height
	Expiration uint64 `protobuf:"varint,2,opt,name=expiration,proto3" json:"expiration,omitempty"`
	// status filters by swap status
	Status SwapStatus `protobuf:"varint,3,opt,name=status,proto3,enum=fury.bep3.v1beta1.SwapStatus" json:"status,omitempty"`
	// direction fitlers by swap direction
	Direction  SwapDirection      `protobuf:"varint,4,opt,name=direction,proto3,enum=fury.bep3.v1beta1.SwapDirection" json:"direction,omitempty"`
	Pagination *query.PageRequest `protobuf:"bytes,5,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryAtomicSwapsRequest proto.InternalMessageInfo

// QueryAtomicSwapsResponse is the response type for the Query/AtomicSwaps RPC method.
type QueryAtomicSwapsResponse struct {
	// atomic_swap represents the returned atomic swaps for the request
	AtomicSwaps []AtomicSwapResponse `protobuf:"bytes,1,rep,name=atomic_swaps,json=atomicSwaps,proto3" json:"atomic_swaps"`
	Pagination  *query.PageResponse  `protobuf:"bytes,3,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryAtomicSwapsResponse proto.InternalMessageInfo

func (m *QueryAtomicSwapsResponse) GetAtomicSwaps() []AtomicSwapResponse {
	if m != nil {
		return m.AtomicSwaps
	}
	return nil
}

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

func init() {
	proto.RegisterType((*QueryParamsRequest)(nil), "fury.bep3.v1beta1.QueryParamsRequest")
	proto.RegisterType((*QueryParamsResponse)(nil), "fury.bep3.v1beta1.QueryParamsResponse")
	proto.RegisterType((*QueryAssetSupplyRequest)(nil), "fury.bep3.v1beta1.QueryAssetSupplyRequest")
	proto.RegisterType((*AssetSupplyResponse)(nil), "fury.bep3.v1beta1.AssetSupplyResponse")
	proto.RegisterType((*QueryAssetSupplyResponse)(nil), "fury.bep3.v1beta1.QueryAssetSupplyResponse")
	proto.RegisterType((*QueryAssetSuppliesRequest)(nil), "fury.bep3.v1beta1.QueryAssetSuppliesRequest")
	proto.RegisterType((*QueryAssetSuppliesResponse)(nil), "fury.bep3.v1beta1.QueryAssetSuppliesResponse")
	proto.RegisterType((*QueryAtomicSwapRequest)(nil), "fury.bep3.v1beta1.QueryAtomicSwapRequest")
	proto.RegisterType((*QueryAtomicSwapResponse)(nil), "fury.bep3.v1beta1.QueryAtomicSwapResponse")
	proto.RegisterType((*AtomicSwapResponse)(nil), "fury.bep3.v1beta1.AtomicSwapResponse")
	proto.RegisterType((*QueryAtomicSwapsRequest)(nil), "fury.bep3.v1beta1.QueryAtomicSwapsRequest")
	proto.RegisterType((*QueryAtomicSwapsResponse)(nil), "fury.bep3.v1beta1.QueryAtomicSwapsResponse")
}

func init() { proto.RegisterFile("fury/bep3/v1beta1/query.proto", fileDescriptor_a5e4082d53c18bf6) }

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

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

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

// QueryClient is the client API for Query service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type QueryClient interface {
	// Params queries module params
	Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error)
	// AssetSupply queries info about an asset's supply
	AssetSupply(ctx context.Context, in *QueryAssetSupplyRequest, opts ...grpc.CallOption) (*QueryAssetSupplyResponse, error)
	// AssetSupplies queries a list of asset supplies
	AssetSupplies(ctx context.Context, in *QueryAssetSuppliesRequest, opts ...grpc.CallOption) (*QueryAssetSuppliesResponse, error)
	// AtomicSwap queries info about an atomic swap
	AtomicSwap(ctx context.Context, in *QueryAtomicSwapRequest, opts ...grpc.CallOption) (*QueryAtomicSwapResponse, error)
	// AtomicSwaps queries a list of atomic swaps
	AtomicSwaps(ctx context.Context, in *QueryAtomicSwapsRequest, opts ...grpc.CallOption) (*QueryAtomicSwapsResponse, error)
}

type queryClient struct {
	cc grpc1.ClientConn
}

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

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

func (c *queryClient) AssetSupply(ctx context.Context, in *QueryAssetSupplyRequest, opts ...grpc.CallOption) (*QueryAssetSupplyResponse, error) {
	out := new(QueryAssetSupplyResponse)
	err := c.cc.Invoke(ctx, "/fury.bep3.v1beta1.Query/AssetSupply", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) AssetSupplies(ctx context.Context, in *QueryAssetSuppliesRequest, opts ...grpc.CallOption) (*QueryAssetSuppliesResponse, error) {
	out := new(QueryAssetSuppliesResponse)
	err := c.cc.Invoke(ctx, "/fury.bep3.v1beta1.Query/AssetSupplies", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) AtomicSwap(ctx context.Context, in *QueryAtomicSwapRequest, opts ...grpc.CallOption) (*QueryAtomicSwapResponse, error) {
	out := new(QueryAtomicSwapResponse)
	err := c.cc.Invoke(ctx, "/fury.bep3.v1beta1.Query/AtomicSwap", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) AtomicSwaps(ctx context.Context, in *QueryAtomicSwapsRequest, opts ...grpc.CallOption) (*QueryAtomicSwapsResponse, error) {
	out := new(QueryAtomicSwapsResponse)
	err := c.cc.Invoke(ctx, "/fury.bep3.v1beta1.Query/AtomicSwaps", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// QueryServer is the server API for Query service.
type QueryServer interface {
	// Params queries module params
	Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error)
	// AssetSupply queries info about an asset's supply
	AssetSupply(context.Context, *QueryAssetSupplyRequest) (*QueryAssetSupplyResponse, error)
	// AssetSupplies queries a list of asset supplies
	AssetSupplies(context.Context, *QueryAssetSuppliesRequest) (*QueryAssetSuppliesResponse, error)
	// AtomicSwap queries info about an atomic swap
	AtomicSwap(context.Context, *QueryAtomicSwapRequest) (*QueryAtomicSwapResponse, error)
	// AtomicSwaps queries a list of atomic swaps
	AtomicSwaps(context.Context, *QueryAtomicSwapsRequest) (*QueryAtomicSwapsResponse, error)
}

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

func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Params not implemented")
}
func (*UnimplementedQueryServer) AssetSupply(ctx context.Context, req *QueryAssetSupplyRequest) (*QueryAssetSupplyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AssetSupply not implemented")
}
func (*UnimplementedQueryServer) AssetSupplies(ctx context.Context, req *QueryAssetSuppliesRequest) (*QueryAssetSuppliesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AssetSupplies not implemented")
}
func (*UnimplementedQueryServer) AtomicSwap(ctx context.Context, req *QueryAtomicSwapRequest) (*QueryAtomicSwapResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AtomicSwap not implemented")
}
func (*UnimplementedQueryServer) AtomicSwaps(ctx context.Context, req *QueryAtomicSwapsRequest) (*QueryAtomicSwapsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AtomicSwaps not implemented")
}

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

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

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

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

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

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

var _Query_serviceDesc = grpc.ServiceDesc{
	ServiceName: "fury.bep3.v1beta1.Query",
	HandlerType: (*QueryServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Params",
			Handler:    _Query_Params_Handler,
		},
		{
			MethodName: "AssetSupply",
			Handler:    _Query_AssetSupply_Handler,
		},
		{
			MethodName: "AssetSupplies",
			Handler:    _Query_AssetSupplies_Handler,
		},
		{
			MethodName: "AtomicSwap",
			Handler:    _Query_AtomicSwap_Handler,
		},
		{
			MethodName: "AtomicSwaps",
			Handler:    _Query_AtomicSwaps_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "fury/bep3/v1beta1/query.proto",
}

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

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

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

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

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

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

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

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

func (m *AssetSupplyResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	n2, err2 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.TimeElapsed, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.TimeElapsed):])
	if err2 != nil {
		return 0, err2
	}
	i -= n2
	i = encodeVarintQuery(dAtA, i, uint64(n2))
	i--
	dAtA[i] = 0x2a
	{
		size, err := m.TimeLimitedCurrentSupply.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintQuery(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size, err := m.CurrentSupply.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintQuery(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size, err := m.OutgoingSupply.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintQuery(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.IncomingSupply.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 *QueryAssetSupplyResponse) 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 *QueryAssetSupplyResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

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

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

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

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

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

func (m *AtomicSwapResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Direction != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.Direction))
		i--
		dAtA[i] = 0x68
	}
	if m.CrossChain {
		i--
		if m.CrossChain {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x60
	}
	if m.Status != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x58
	}
	if m.ClosedBlock != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.ClosedBlock))
		i--
		dAtA[i] = 0x50
	}
	if len(m.RecipientOtherChain) > 0 {
		i -= len(m.RecipientOtherChain)
		copy(dAtA[i:], m.RecipientOtherChain)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.RecipientOtherChain)))
		i--
		dAtA[i] = 0x4a
	}
	if len(m.SenderOtherChain) > 0 {
		i -= len(m.SenderOtherChain)
		copy(dAtA[i:], m.SenderOtherChain)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.SenderOtherChain)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.Recipient) > 0 {
		i -= len(m.Recipient)
		copy(dAtA[i:], m.Recipient)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.Recipient)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0x32
	}
	if m.Timestamp != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.Timestamp))
		i--
		dAtA[i] = 0x28
	}
	if m.ExpireHeight != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.ExpireHeight))
		i--
		dAtA[i] = 0x20
	}
	if len(m.RandomNumberHash) > 0 {
		i -= len(m.RandomNumberHash)
		copy(dAtA[i:], m.RandomNumberHash)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.RandomNumberHash)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Amount) > 0 {
		for iNdEx := len(m.Amount) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Amount[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQuery(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *QueryAtomicSwapsRequest) 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] = 0x2a
	}
	if m.Direction != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.Direction))
		i--
		dAtA[i] = 0x20
	}
	if m.Status != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x18
	}
	if m.Expiration != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.Expiration))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Involve) > 0 {
		i -= len(m.Involve)
		copy(dAtA[i:], m.Involve)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.Involve)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *QueryAtomicSwapsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Pagination != nil {
		{
			size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQuery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.AtomicSwaps) > 0 {
		for iNdEx := len(m.AtomicSwaps) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.AtomicSwaps[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 encodeVarintQuery(dAtA []byte, offset int, v uint64) int {
	offset -= sovQuery(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *QueryParamsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

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

func (m *QueryAssetSupplyRequest) 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 *AssetSupplyResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.IncomingSupply.Size()
	n += 1 + l + sovQuery(uint64(l))
	l = m.OutgoingSupply.Size()
	n += 1 + l + sovQuery(uint64(l))
	l = m.CurrentSupply.Size()
	n += 1 + l + sovQuery(uint64(l))
	l = m.TimeLimitedCurrentSupply.Size()
	n += 1 + l + sovQuery(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.TimeElapsed)
	n += 1 + l + sovQuery(uint64(l))
	return n
}

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

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

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

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

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

func (m *AtomicSwapResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if len(m.Amount) > 0 {
		for _, e := range m.Amount {
			l = e.Size()
			n += 1 + l + sovQuery(uint64(l))
		}
	}
	l = len(m.RandomNumberHash)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if m.ExpireHeight != 0 {
		n += 1 + sovQuery(uint64(m.ExpireHeight))
	}
	if m.Timestamp != 0 {
		n += 1 + sovQuery(uint64(m.Timestamp))
	}
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.Recipient)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.SenderOtherChain)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.RecipientOtherChain)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if m.ClosedBlock != 0 {
		n += 1 + sovQuery(uint64(m.ClosedBlock))
	}
	if m.Status != 0 {
		n += 1 + sovQuery(uint64(m.Status))
	}
	if m.CrossChain {
		n += 2
	}
	if m.Direction != 0 {
		n += 1 + sovQuery(uint64(m.Direction))
	}
	return n
}

func (m *QueryAtomicSwapsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Involve)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if m.Expiration != 0 {
		n += 1 + sovQuery(uint64(m.Expiration))
	}
	if m.Status != 0 {
		n += 1 + sovQuery(uint64(m.Status))
	}
	if m.Direction != 0 {
		n += 1 + sovQuery(uint64(m.Direction))
	}
	if m.Pagination != nil {
		l = m.Pagination.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryAtomicSwapsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.AtomicSwaps) > 0 {
		for _, e := range m.AtomicSwaps {
			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 sovQuery(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozQuery(x uint64) (n int) {
	return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *QueryParamsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryParamsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryParamsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryAssetSupplyRequest) 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: QueryAssetSupplyRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryAssetSupplyRequest: 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 *AssetSupplyResponse) 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: AssetSupplyResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AssetSupplyResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IncomingSupply", 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.IncomingSupply.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OutgoingSupply", 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.OutgoingSupply.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CurrentSupply", 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.CurrentSupply.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TimeLimitedCurrentSupply", 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.TimeLimitedCurrentSupply.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TimeElapsed", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.TimeElapsed, 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 *QueryAssetSupplyResponse) 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: QueryAssetSupplyResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryAssetSupplyResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AssetSupply", 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.AssetSupply.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 *QueryAssetSuppliesRequest) 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: QueryAssetSuppliesRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryAssetSuppliesRequest: 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 *QueryAssetSuppliesResponse) 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: QueryAssetSuppliesResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryAssetSuppliesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AssetSupplies", 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.AssetSupplies = append(m.AssetSupplies, AssetSupplyResponse{})
			if err := m.AssetSupplies[len(m.AssetSupplies)-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 *QueryAtomicSwapRequest) 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: QueryAtomicSwapRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryAtomicSwapRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SwapId", 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.SwapId = 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 *QueryAtomicSwapResponse) 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: QueryAtomicSwapResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryAtomicSwapResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AtomicSwap", 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.AtomicSwap.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 *AtomicSwapResponse) 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: AtomicSwapResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AtomicSwapResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", 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.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Amount = append(m.Amount, types.Coin{})
			if err := m.Amount[len(m.Amount)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RandomNumberHash", 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.RandomNumberHash = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExpireHeight", wireType)
			}
			m.ExpireHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ExpireHeight |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			m.Timestamp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Timestamp |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", 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.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Recipient", 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.Recipient = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SenderOtherChain", 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.SenderOtherChain = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RecipientOtherChain", 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.RecipientOtherChain = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClosedBlock", wireType)
			}
			m.ClosedBlock = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ClosedBlock |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= SwapStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CrossChain", 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.CrossChain = bool(v != 0)
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Direction", wireType)
			}
			m.Direction = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Direction |= SwapDirection(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 *QueryAtomicSwapsRequest) 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: QueryAtomicSwapsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryAtomicSwapsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Involve", 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.Involve = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Expiration", wireType)
			}
			m.Expiration = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Expiration |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= SwapStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Direction", wireType)
			}
			m.Direction = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Direction |= SwapDirection(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			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 *QueryAtomicSwapsResponse) 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: QueryAtomicSwapsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryAtomicSwapsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AtomicSwaps", 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.AtomicSwaps = append(m.AtomicSwaps, AtomicSwapResponse{})
			if err := m.AtomicSwaps[len(m.AtomicSwaps)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field 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")
)