go-cyber/x/liquidity/types/query.pb.go

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

package types

import (
	context "context"
	fmt "fmt"
	io "io"
	math "math"
	math_bits "math/bits"

	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"
)

// Reference imports to suppress errors if they are not otherwise used.
var (
	_ = proto.Marshal
	_ = fmt.Errorf
	_ = 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

// the request type for the QueryLiquidityPool RPC method. requestable specified
// pool_id.
type QueryLiquidityPoolRequest struct {
	PoolId uint64 `protobuf:"varint,1,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty"`
}

func (m *QueryLiquidityPoolRequest) Reset()         { *m = QueryLiquidityPoolRequest{} }
func (m *QueryLiquidityPoolRequest) String() string { return proto.CompactTextString(m) }
func (*QueryLiquidityPoolRequest) ProtoMessage()    {}
func (*QueryLiquidityPoolRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_456c121a8965f63a, []int{0}
}

func (m *QueryLiquidityPoolRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryLiquidityPoolRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryLiquidityPoolRequest.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 *QueryLiquidityPoolRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryLiquidityPoolRequest.Merge(m, src)
}

func (m *QueryLiquidityPoolRequest) XXX_Size() int {
	return m.Size()
}

func (m *QueryLiquidityPoolRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryLiquidityPoolRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryLiquidityPoolRequest proto.InternalMessageInfo

func (m *QueryLiquidityPoolRequest) GetPoolId() uint64 {
	if m != nil {
		return m.PoolId
	}
	return 0
}

// the response type for the QueryLiquidityPoolResponse RPC method. Returns the
// liquidity pool that corresponds to the requested pool_id.
type QueryLiquidityPoolResponse struct {
	Pool Pool `protobuf:"bytes,1,opt,name=pool,proto3" json:"pool"`
}

func (m *QueryLiquidityPoolResponse) Reset()         { *m = QueryLiquidityPoolResponse{} }
func (m *QueryLiquidityPoolResponse) String() string { return proto.CompactTextString(m) }
func (*QueryLiquidityPoolResponse) ProtoMessage()    {}
func (*QueryLiquidityPoolResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_456c121a8965f63a, []int{1}
}

func (m *QueryLiquidityPoolResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryLiquidityPoolResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryLiquidityPoolResponse.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 *QueryLiquidityPoolResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryLiquidityPoolResponse.Merge(m, src)
}

func (m *QueryLiquidityPoolResponse) XXX_Size() int {
	return m.Size()
}

func (m *QueryLiquidityPoolResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryLiquidityPoolResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryLiquidityPoolResponse proto.InternalMessageInfo

func (m *QueryLiquidityPoolResponse) GetPool() Pool {
	if m != nil {
		return m.Pool
	}
	return Pool{}
}

// the request type for the QueryLiquidityByPoolCoinDenomPool RPC method.
// Requestable specified pool_coin_denom.
type QueryLiquidityPoolByPoolCoinDenomRequest struct {
	PoolCoinDenom string `protobuf:"bytes,1,opt,name=pool_coin_denom,json=poolCoinDenom,proto3" json:"pool_coin_denom,omitempty"`
}

func (m *QueryLiquidityPoolByPoolCoinDenomRequest) Reset() {
	*m = QueryLiquidityPoolByPoolCoinDenomRequest{}
}
func (m *QueryLiquidityPoolByPoolCoinDenomRequest) String() string { return proto.CompactTextString(m) }
func (*QueryLiquidityPoolByPoolCoinDenomRequest) ProtoMessage()    {}
func (*QueryLiquidityPoolByPoolCoinDenomRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_456c121a8965f63a, []int{2}
}

func (m *QueryLiquidityPoolByPoolCoinDenomRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryLiquidityPoolByPoolCoinDenomRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryLiquidityPoolByPoolCoinDenomRequest.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 *QueryLiquidityPoolByPoolCoinDenomRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryLiquidityPoolByPoolCoinDenomRequest.Merge(m, src)
}

func (m *QueryLiquidityPoolByPoolCoinDenomRequest) XXX_Size() int {
	return m.Size()
}

func (m *QueryLiquidityPoolByPoolCoinDenomRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryLiquidityPoolByPoolCoinDenomRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryLiquidityPoolByPoolCoinDenomRequest proto.InternalMessageInfo

func (m *QueryLiquidityPoolByPoolCoinDenomRequest) GetPoolCoinDenom() string {
	if m != nil {
		return m.PoolCoinDenom
	}
	return ""
}

// the request type for the QueryLiquidityByReserveAcc RPC method. Requestable
// specified reserve_acc.
type QueryLiquidityPoolByReserveAccRequest struct {
	ReserveAcc string `protobuf:"bytes,1,opt,name=reserve_acc,json=reserveAcc,proto3" json:"reserve_acc,omitempty"`
}

func (m *QueryLiquidityPoolByReserveAccRequest) Reset()         { *m = QueryLiquidityPoolByReserveAccRequest{} }
func (m *QueryLiquidityPoolByReserveAccRequest) String() string { return proto.CompactTextString(m) }
func (*QueryLiquidityPoolByReserveAccRequest) ProtoMessage()    {}
func (*QueryLiquidityPoolByReserveAccRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_456c121a8965f63a, []int{3}
}

func (m *QueryLiquidityPoolByReserveAccRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryLiquidityPoolByReserveAccRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryLiquidityPoolByReserveAccRequest.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 *QueryLiquidityPoolByReserveAccRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryLiquidityPoolByReserveAccRequest.Merge(m, src)
}

func (m *QueryLiquidityPoolByReserveAccRequest) XXX_Size() int {
	return m.Size()
}

func (m *QueryLiquidityPoolByReserveAccRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryLiquidityPoolByReserveAccRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryLiquidityPoolByReserveAccRequest proto.InternalMessageInfo

func (m *QueryLiquidityPoolByReserveAccRequest) GetReserveAcc() string {
	if m != nil {
		return m.ReserveAcc
	}
	return ""
}

// the request type for the QueryLiquidityPoolBatch RPC method. requestable
// including specified pool_id.
type QueryLiquidityPoolBatchRequest struct {
	// id of the target pool for query
	PoolId uint64 `protobuf:"varint,1,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty"`
}

func (m *QueryLiquidityPoolBatchRequest) Reset()         { *m = QueryLiquidityPoolBatchRequest{} }
func (m *QueryLiquidityPoolBatchRequest) String() string { return proto.CompactTextString(m) }
func (*QueryLiquidityPoolBatchRequest) ProtoMessage()    {}
func (*QueryLiquidityPoolBatchRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_456c121a8965f63a, []int{4}
}

func (m *QueryLiquidityPoolBatchRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryLiquidityPoolBatchRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryLiquidityPoolBatchRequest.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 *QueryLiquidityPoolBatchRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryLiquidityPoolBatchRequest.Merge(m, src)
}

func (m *QueryLiquidityPoolBatchRequest) XXX_Size() int {
	return m.Size()
}

func (m *QueryLiquidityPoolBatchRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryLiquidityPoolBatchRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryLiquidityPoolBatchRequest proto.InternalMessageInfo

func (m *QueryLiquidityPoolBatchRequest) GetPoolId() uint64 {
	if m != nil {
		return m.PoolId
	}
	return 0
}

// the response type for the QueryLiquidityPoolBatchResponse RPC method. Returns
// the liquidity pool batch that corresponds to the requested pool_id.
type QueryLiquidityPoolBatchResponse struct {
	Batch PoolBatch `protobuf:"bytes,1,opt,name=batch,proto3" json:"batch"`
}

func (m *QueryLiquidityPoolBatchResponse) Reset()         { *m = QueryLiquidityPoolBatchResponse{} }
func (m *QueryLiquidityPoolBatchResponse) String() string { return proto.CompactTextString(m) }
func (*QueryLiquidityPoolBatchResponse) ProtoMessage()    {}
func (*QueryLiquidityPoolBatchResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_456c121a8965f63a, []int{5}
}

func (m *QueryLiquidityPoolBatchResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryLiquidityPoolBatchResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryLiquidityPoolBatchResponse.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 *QueryLiquidityPoolBatchResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryLiquidityPoolBatchResponse.Merge(m, src)
}

func (m *QueryLiquidityPoolBatchResponse) XXX_Size() int {
	return m.Size()
}

func (m *QueryLiquidityPoolBatchResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryLiquidityPoolBatchResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryLiquidityPoolBatchResponse proto.InternalMessageInfo

func (m *QueryLiquidityPoolBatchResponse) GetBatch() PoolBatch {
	if m != nil {
		return m.Batch
	}
	return PoolBatch{}
}

// the request type for the QueryLiquidityPools RPC method. Requestable
// including pagination offset, limit, key.
type QueryLiquidityPoolsRequest struct {
	// pagination defines an optional pagination for the request.
	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

func (m *QueryLiquidityPoolsRequest) Reset()         { *m = QueryLiquidityPoolsRequest{} }
func (m *QueryLiquidityPoolsRequest) String() string { return proto.CompactTextString(m) }
func (*QueryLiquidityPoolsRequest) ProtoMessage()    {}
func (*QueryLiquidityPoolsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_456c121a8965f63a, []int{6}
}

func (m *QueryLiquidityPoolsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryLiquidityPoolsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryLiquidityPoolsRequest.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 *QueryLiquidityPoolsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryLiquidityPoolsRequest.Merge(m, src)
}

func (m *QueryLiquidityPoolsRequest) XXX_Size() int {
	return m.Size()
}

func (m *QueryLiquidityPoolsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryLiquidityPoolsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryLiquidityPoolsRequest proto.InternalMessageInfo

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

// the response type for the QueryLiquidityPoolsResponse RPC method. This
// includes a list of all existing liquidity pools and paging results that
// contain next_key and total count.
type QueryLiquidityPoolsResponse struct {
	Pools []Pool `protobuf:"bytes,1,rep,name=pools,proto3" json:"pools"`
	// pagination defines the pagination in the response. not working on this
	// version.
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

func (m *QueryLiquidityPoolsResponse) Reset()         { *m = QueryLiquidityPoolsResponse{} }
func (m *QueryLiquidityPoolsResponse) String() string { return proto.CompactTextString(m) }
func (*QueryLiquidityPoolsResponse) ProtoMessage()    {}
func (*QueryLiquidityPoolsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_456c121a8965f63a, []int{7}
}

func (m *QueryLiquidityPoolsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryLiquidityPoolsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryLiquidityPoolsResponse.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 *QueryLiquidityPoolsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryLiquidityPoolsResponse.Merge(m, src)
}

func (m *QueryLiquidityPoolsResponse) XXX_Size() int {
	return m.Size()
}

func (m *QueryLiquidityPoolsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryLiquidityPoolsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryLiquidityPoolsResponse proto.InternalMessageInfo

func (m *QueryLiquidityPoolsResponse) GetPools() []Pool {
	if m != nil {
		return m.Pools
	}
	return nil
}

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

// QueryParamsRequest is request type for the QueryParams 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_456c121a8965f63a, []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

// the response type for the QueryParamsResponse RPC method. This includes
// current parameter of the liquidity module.
type QueryParamsResponse struct {
	// params holds all the parameters of this 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_456c121a8965f63a, []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{}
}

// the request type for the QueryPoolBatchSwapMsgs RPC method. Requestable
// including specified pool_id and pagination offset, limit, key.
type QueryPoolBatchSwapMsgsRequest struct {
	// id of the target pool for query
	PoolId uint64 `protobuf:"varint,1,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty"`
	// pagination defines an optional pagination for the request.
	Pagination *query.PageRequest `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

func (m *QueryPoolBatchSwapMsgsRequest) Reset()         { *m = QueryPoolBatchSwapMsgsRequest{} }
func (m *QueryPoolBatchSwapMsgsRequest) String() string { return proto.CompactTextString(m) }
func (*QueryPoolBatchSwapMsgsRequest) ProtoMessage()    {}
func (*QueryPoolBatchSwapMsgsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_456c121a8965f63a, []int{10}
}

func (m *QueryPoolBatchSwapMsgsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryPoolBatchSwapMsgsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryPoolBatchSwapMsgsRequest.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 *QueryPoolBatchSwapMsgsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryPoolBatchSwapMsgsRequest.Merge(m, src)
}

func (m *QueryPoolBatchSwapMsgsRequest) XXX_Size() int {
	return m.Size()
}

func (m *QueryPoolBatchSwapMsgsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryPoolBatchSwapMsgsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryPoolBatchSwapMsgsRequest proto.InternalMessageInfo

func (m *QueryPoolBatchSwapMsgsRequest) GetPoolId() uint64 {
	if m != nil {
		return m.PoolId
	}
	return 0
}

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

// the request type for the QueryPoolBatchSwap RPC method. Requestable including
// specified pool_id and msg_index.
type QueryPoolBatchSwapMsgRequest struct {
	// id of the target pool for query
	PoolId uint64 `protobuf:"varint,1,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty"`
	// target msg_index of the pool
	MsgIndex uint64 `protobuf:"varint,2,opt,name=msg_index,json=msgIndex,proto3" json:"msg_index,omitempty"`
}

func (m *QueryPoolBatchSwapMsgRequest) Reset()         { *m = QueryPoolBatchSwapMsgRequest{} }
func (m *QueryPoolBatchSwapMsgRequest) String() string { return proto.CompactTextString(m) }
func (*QueryPoolBatchSwapMsgRequest) ProtoMessage()    {}
func (*QueryPoolBatchSwapMsgRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_456c121a8965f63a, []int{11}
}

func (m *QueryPoolBatchSwapMsgRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryPoolBatchSwapMsgRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryPoolBatchSwapMsgRequest.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 *QueryPoolBatchSwapMsgRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryPoolBatchSwapMsgRequest.Merge(m, src)
}

func (m *QueryPoolBatchSwapMsgRequest) XXX_Size() int {
	return m.Size()
}

func (m *QueryPoolBatchSwapMsgRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryPoolBatchSwapMsgRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryPoolBatchSwapMsgRequest proto.InternalMessageInfo

func (m *QueryPoolBatchSwapMsgRequest) GetPoolId() uint64 {
	if m != nil {
		return m.PoolId
	}
	return 0
}

func (m *QueryPoolBatchSwapMsgRequest) GetMsgIndex() uint64 {
	if m != nil {
		return m.MsgIndex
	}
	return 0
}

// the response type for the QueryPoolBatchSwapMsgs RPC method. This includes
// list of all currently existing swap messages of the batch and paging results
// that contain next_key and total count.
type QueryPoolBatchSwapMsgsResponse struct {
	Swaps []SwapMsgState `protobuf:"bytes,1,rep,name=swaps,proto3" json:"swaps"`
	// pagination defines the pagination in the response. not working on this
	// version.
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

func (m *QueryPoolBatchSwapMsgsResponse) Reset()         { *m = QueryPoolBatchSwapMsgsResponse{} }
func (m *QueryPoolBatchSwapMsgsResponse) String() string { return proto.CompactTextString(m) }
func (*QueryPoolBatchSwapMsgsResponse) ProtoMessage()    {}
func (*QueryPoolBatchSwapMsgsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_456c121a8965f63a, []int{12}
}

func (m *QueryPoolBatchSwapMsgsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryPoolBatchSwapMsgsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryPoolBatchSwapMsgsResponse.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 *QueryPoolBatchSwapMsgsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryPoolBatchSwapMsgsResponse.Merge(m, src)
}

func (m *QueryPoolBatchSwapMsgsResponse) XXX_Size() int {
	return m.Size()
}

func (m *QueryPoolBatchSwapMsgsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryPoolBatchSwapMsgsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryPoolBatchSwapMsgsResponse proto.InternalMessageInfo

func (m *QueryPoolBatchSwapMsgsResponse) GetSwaps() []SwapMsgState {
	if m != nil {
		return m.Swaps
	}
	return nil
}

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

// the response type for the QueryPoolBatchSwapMsg RPC method. This includes a
// batch swap message of the batch.
type QueryPoolBatchSwapMsgResponse struct {
	Swap SwapMsgState `protobuf:"bytes,1,opt,name=swap,proto3" json:"swap"`
}

func (m *QueryPoolBatchSwapMsgResponse) Reset()         { *m = QueryPoolBatchSwapMsgResponse{} }
func (m *QueryPoolBatchSwapMsgResponse) String() string { return proto.CompactTextString(m) }
func (*QueryPoolBatchSwapMsgResponse) ProtoMessage()    {}
func (*QueryPoolBatchSwapMsgResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_456c121a8965f63a, []int{13}
}

func (m *QueryPoolBatchSwapMsgResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryPoolBatchSwapMsgResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryPoolBatchSwapMsgResponse.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 *QueryPoolBatchSwapMsgResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryPoolBatchSwapMsgResponse.Merge(m, src)
}

func (m *QueryPoolBatchSwapMsgResponse) XXX_Size() int {
	return m.Size()
}

func (m *QueryPoolBatchSwapMsgResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryPoolBatchSwapMsgResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryPoolBatchSwapMsgResponse proto.InternalMessageInfo

func (m *QueryPoolBatchSwapMsgResponse) GetSwap() SwapMsgState {
	if m != nil {
		return m.Swap
	}
	return SwapMsgState{}
}

// the request type for the QueryPoolBatchDeposit RPC method. Requestable
// including specified pool_id and pagination offset, limit, key.
type QueryPoolBatchDepositMsgsRequest struct {
	// id of the target pool for query
	PoolId uint64 `protobuf:"varint,1,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty"`
	// pagination defines an optional pagination for the request.
	Pagination *query.PageRequest `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

func (m *QueryPoolBatchDepositMsgsRequest) Reset()         { *m = QueryPoolBatchDepositMsgsRequest{} }
func (m *QueryPoolBatchDepositMsgsRequest) String() string { return proto.CompactTextString(m) }
func (*QueryPoolBatchDepositMsgsRequest) ProtoMessage()    {}
func (*QueryPoolBatchDepositMsgsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_456c121a8965f63a, []int{14}
}

func (m *QueryPoolBatchDepositMsgsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryPoolBatchDepositMsgsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryPoolBatchDepositMsgsRequest.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 *QueryPoolBatchDepositMsgsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryPoolBatchDepositMsgsRequest.Merge(m, src)
}

func (m *QueryPoolBatchDepositMsgsRequest) XXX_Size() int {
	return m.Size()
}

func (m *QueryPoolBatchDepositMsgsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryPoolBatchDepositMsgsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryPoolBatchDepositMsgsRequest proto.InternalMessageInfo

func (m *QueryPoolBatchDepositMsgsRequest) GetPoolId() uint64 {
	if m != nil {
		return m.PoolId
	}
	return 0
}

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

// the request type for the QueryPoolBatchDeposit RPC method. requestable
// including specified pool_id and msg_index.
type QueryPoolBatchDepositMsgRequest struct {
	// id of the target pool for query
	PoolId uint64 `protobuf:"varint,1,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty"`
	// target msg_index of the pool
	MsgIndex uint64 `protobuf:"varint,2,opt,name=msg_index,json=msgIndex,proto3" json:"msg_index,omitempty"`
}

func (m *QueryPoolBatchDepositMsgRequest) Reset()         { *m = QueryPoolBatchDepositMsgRequest{} }
func (m *QueryPoolBatchDepositMsgRequest) String() string { return proto.CompactTextString(m) }
func (*QueryPoolBatchDepositMsgRequest) ProtoMessage()    {}
func (*QueryPoolBatchDepositMsgRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_456c121a8965f63a, []int{15}
}

func (m *QueryPoolBatchDepositMsgRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryPoolBatchDepositMsgRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryPoolBatchDepositMsgRequest.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 *QueryPoolBatchDepositMsgRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryPoolBatchDepositMsgRequest.Merge(m, src)
}

func (m *QueryPoolBatchDepositMsgRequest) XXX_Size() int {
	return m.Size()
}

func (m *QueryPoolBatchDepositMsgRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryPoolBatchDepositMsgRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryPoolBatchDepositMsgRequest proto.InternalMessageInfo

func (m *QueryPoolBatchDepositMsgRequest) GetPoolId() uint64 {
	if m != nil {
		return m.PoolId
	}
	return 0
}

func (m *QueryPoolBatchDepositMsgRequest) GetMsgIndex() uint64 {
	if m != nil {
		return m.MsgIndex
	}
	return 0
}

// the response type for the QueryPoolBatchDeposit RPC method. This includes a
// list of all currently existing deposit messages of the batch and paging
// results that contain next_key and total count.
type QueryPoolBatchDepositMsgsResponse struct {
	Deposits []DepositMsgState `protobuf:"bytes,1,rep,name=deposits,proto3" json:"deposits"`
	// pagination defines the pagination in the response. not working on this
	// version.
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

func (m *QueryPoolBatchDepositMsgsResponse) Reset()         { *m = QueryPoolBatchDepositMsgsResponse{} }
func (m *QueryPoolBatchDepositMsgsResponse) String() string { return proto.CompactTextString(m) }
func (*QueryPoolBatchDepositMsgsResponse) ProtoMessage()    {}
func (*QueryPoolBatchDepositMsgsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_456c121a8965f63a, []int{16}
}

func (m *QueryPoolBatchDepositMsgsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryPoolBatchDepositMsgsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryPoolBatchDepositMsgsResponse.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 *QueryPoolBatchDepositMsgsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryPoolBatchDepositMsgsResponse.Merge(m, src)
}

func (m *QueryPoolBatchDepositMsgsResponse) XXX_Size() int {
	return m.Size()
}

func (m *QueryPoolBatchDepositMsgsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryPoolBatchDepositMsgsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryPoolBatchDepositMsgsResponse proto.InternalMessageInfo

func (m *QueryPoolBatchDepositMsgsResponse) GetDeposits() []DepositMsgState {
	if m != nil {
		return m.Deposits
	}
	return nil
}

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

// the response type for the QueryPoolBatchDepositMsg RPC method. This includes
// a batch swap message of the batch.
type QueryPoolBatchDepositMsgResponse struct {
	Deposit DepositMsgState `protobuf:"bytes,1,opt,name=deposit,proto3" json:"deposit"`
}

func (m *QueryPoolBatchDepositMsgResponse) Reset()         { *m = QueryPoolBatchDepositMsgResponse{} }
func (m *QueryPoolBatchDepositMsgResponse) String() string { return proto.CompactTextString(m) }
func (*QueryPoolBatchDepositMsgResponse) ProtoMessage()    {}
func (*QueryPoolBatchDepositMsgResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_456c121a8965f63a, []int{17}
}

func (m *QueryPoolBatchDepositMsgResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryPoolBatchDepositMsgResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryPoolBatchDepositMsgResponse.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 *QueryPoolBatchDepositMsgResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryPoolBatchDepositMsgResponse.Merge(m, src)
}

func (m *QueryPoolBatchDepositMsgResponse) XXX_Size() int {
	return m.Size()
}

func (m *QueryPoolBatchDepositMsgResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryPoolBatchDepositMsgResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryPoolBatchDepositMsgResponse proto.InternalMessageInfo

func (m *QueryPoolBatchDepositMsgResponse) GetDeposit() DepositMsgState {
	if m != nil {
		return m.Deposit
	}
	return DepositMsgState{}
}

// the request type for the QueryPoolBatchWithdraw RPC method. Requestable
// including specified pool_id and pagination offset, limit, key.
type QueryPoolBatchWithdrawMsgsRequest struct {
	// id of the target pool for query
	PoolId uint64 `protobuf:"varint,1,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty"`
	// pagination defines an optional pagination for the request.
	Pagination *query.PageRequest `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

func (m *QueryPoolBatchWithdrawMsgsRequest) Reset()         { *m = QueryPoolBatchWithdrawMsgsRequest{} }
func (m *QueryPoolBatchWithdrawMsgsRequest) String() string { return proto.CompactTextString(m) }
func (*QueryPoolBatchWithdrawMsgsRequest) ProtoMessage()    {}
func (*QueryPoolBatchWithdrawMsgsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_456c121a8965f63a, []int{18}
}

func (m *QueryPoolBatchWithdrawMsgsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryPoolBatchWithdrawMsgsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryPoolBatchWithdrawMsgsRequest.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 *QueryPoolBatchWithdrawMsgsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryPoolBatchWithdrawMsgsRequest.Merge(m, src)
}

func (m *QueryPoolBatchWithdrawMsgsRequest) XXX_Size() int {
	return m.Size()
}

func (m *QueryPoolBatchWithdrawMsgsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryPoolBatchWithdrawMsgsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryPoolBatchWithdrawMsgsRequest proto.InternalMessageInfo

func (m *QueryPoolBatchWithdrawMsgsRequest) GetPoolId() uint64 {
	if m != nil {
		return m.PoolId
	}
	return 0
}

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

// the request type for the QueryPoolBatchWithdraw RPC method. requestable
// including specified pool_id and msg_index.
type QueryPoolBatchWithdrawMsgRequest struct {
	// id of the target pool for query
	PoolId uint64 `protobuf:"varint,1,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty"`
	// target msg_index of the pool
	MsgIndex uint64 `protobuf:"varint,2,opt,name=msg_index,json=msgIndex,proto3" json:"msg_index,omitempty"`
}

func (m *QueryPoolBatchWithdrawMsgRequest) Reset()         { *m = QueryPoolBatchWithdrawMsgRequest{} }
func (m *QueryPoolBatchWithdrawMsgRequest) String() string { return proto.CompactTextString(m) }
func (*QueryPoolBatchWithdrawMsgRequest) ProtoMessage()    {}
func (*QueryPoolBatchWithdrawMsgRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_456c121a8965f63a, []int{19}
}

func (m *QueryPoolBatchWithdrawMsgRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryPoolBatchWithdrawMsgRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryPoolBatchWithdrawMsgRequest.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 *QueryPoolBatchWithdrawMsgRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryPoolBatchWithdrawMsgRequest.Merge(m, src)
}

func (m *QueryPoolBatchWithdrawMsgRequest) XXX_Size() int {
	return m.Size()
}

func (m *QueryPoolBatchWithdrawMsgRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryPoolBatchWithdrawMsgRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryPoolBatchWithdrawMsgRequest proto.InternalMessageInfo

func (m *QueryPoolBatchWithdrawMsgRequest) GetPoolId() uint64 {
	if m != nil {
		return m.PoolId
	}
	return 0
}

func (m *QueryPoolBatchWithdrawMsgRequest) GetMsgIndex() uint64 {
	if m != nil {
		return m.MsgIndex
	}
	return 0
}

// the response type for the QueryPoolBatchWithdraw RPC method. This includes a
// list of all currently existing withdraw messages of the batch and paging
// results that contain next_key and total count.
type QueryPoolBatchWithdrawMsgsResponse struct {
	Withdraws []WithdrawMsgState `protobuf:"bytes,1,rep,name=withdraws,proto3" json:"withdraws"`
	// pagination defines the pagination in the response. Not supported on this
	// version.
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

func (m *QueryPoolBatchWithdrawMsgsResponse) Reset()         { *m = QueryPoolBatchWithdrawMsgsResponse{} }
func (m *QueryPoolBatchWithdrawMsgsResponse) String() string { return proto.CompactTextString(m) }
func (*QueryPoolBatchWithdrawMsgsResponse) ProtoMessage()    {}
func (*QueryPoolBatchWithdrawMsgsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_456c121a8965f63a, []int{20}
}

func (m *QueryPoolBatchWithdrawMsgsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryPoolBatchWithdrawMsgsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryPoolBatchWithdrawMsgsResponse.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 *QueryPoolBatchWithdrawMsgsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryPoolBatchWithdrawMsgsResponse.Merge(m, src)
}

func (m *QueryPoolBatchWithdrawMsgsResponse) XXX_Size() int {
	return m.Size()
}

func (m *QueryPoolBatchWithdrawMsgsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryPoolBatchWithdrawMsgsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryPoolBatchWithdrawMsgsResponse proto.InternalMessageInfo

func (m *QueryPoolBatchWithdrawMsgsResponse) GetWithdraws() []WithdrawMsgState {
	if m != nil {
		return m.Withdraws
	}
	return nil
}

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

// the response type for the QueryPoolBatchWithdrawMsg RPC method. This includes
// a batch swap message of the batch.
type QueryPoolBatchWithdrawMsgResponse struct {
	Withdraw WithdrawMsgState `protobuf:"bytes,1,opt,name=withdraw,proto3" json:"withdraw"`
}

func (m *QueryPoolBatchWithdrawMsgResponse) Reset()         { *m = QueryPoolBatchWithdrawMsgResponse{} }
func (m *QueryPoolBatchWithdrawMsgResponse) String() string { return proto.CompactTextString(m) }
func (*QueryPoolBatchWithdrawMsgResponse) ProtoMessage()    {}
func (*QueryPoolBatchWithdrawMsgResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_456c121a8965f63a, []int{21}
}

func (m *QueryPoolBatchWithdrawMsgResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryPoolBatchWithdrawMsgResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryPoolBatchWithdrawMsgResponse.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 *QueryPoolBatchWithdrawMsgResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryPoolBatchWithdrawMsgResponse.Merge(m, src)
}

func (m *QueryPoolBatchWithdrawMsgResponse) XXX_Size() int {
	return m.Size()
}

func (m *QueryPoolBatchWithdrawMsgResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryPoolBatchWithdrawMsgResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryPoolBatchWithdrawMsgResponse proto.InternalMessageInfo

func (m *QueryPoolBatchWithdrawMsgResponse) GetWithdraw() WithdrawMsgState {
	if m != nil {
		return m.Withdraw
	}
	return WithdrawMsgState{}
}

func init() {
	proto.RegisterType((*QueryLiquidityPoolRequest)(nil), "cyber.liquidity.v1beta1.QueryLiquidityPoolRequest")
	proto.RegisterType((*QueryLiquidityPoolResponse)(nil), "cyber.liquidity.v1beta1.QueryLiquidityPoolResponse")
	proto.RegisterType((*QueryLiquidityPoolByPoolCoinDenomRequest)(nil), "cyber.liquidity.v1beta1.QueryLiquidityPoolByPoolCoinDenomRequest")
	proto.RegisterType((*QueryLiquidityPoolByReserveAccRequest)(nil), "cyber.liquidity.v1beta1.QueryLiquidityPoolByReserveAccRequest")
	proto.RegisterType((*QueryLiquidityPoolBatchRequest)(nil), "cyber.liquidity.v1beta1.QueryLiquidityPoolBatchRequest")
	proto.RegisterType((*QueryLiquidityPoolBatchResponse)(nil), "cyber.liquidity.v1beta1.QueryLiquidityPoolBatchResponse")
	proto.RegisterType((*QueryLiquidityPoolsRequest)(nil), "cyber.liquidity.v1beta1.QueryLiquidityPoolsRequest")
	proto.RegisterType((*QueryLiquidityPoolsResponse)(nil), "cyber.liquidity.v1beta1.QueryLiquidityPoolsResponse")
	proto.RegisterType((*QueryParamsRequest)(nil), "cyber.liquidity.v1beta1.QueryParamsRequest")
	proto.RegisterType((*QueryParamsResponse)(nil), "cyber.liquidity.v1beta1.QueryParamsResponse")
	proto.RegisterType((*QueryPoolBatchSwapMsgsRequest)(nil), "cyber.liquidity.v1beta1.QueryPoolBatchSwapMsgsRequest")
	proto.RegisterType((*QueryPoolBatchSwapMsgRequest)(nil), "cyber.liquidity.v1beta1.QueryPoolBatchSwapMsgRequest")
	proto.RegisterType((*QueryPoolBatchSwapMsgsResponse)(nil), "cyber.liquidity.v1beta1.QueryPoolBatchSwapMsgsResponse")
	proto.RegisterType((*QueryPoolBatchSwapMsgResponse)(nil), "cyber.liquidity.v1beta1.QueryPoolBatchSwapMsgResponse")
	proto.RegisterType((*QueryPoolBatchDepositMsgsRequest)(nil), "cyber.liquidity.v1beta1.QueryPoolBatchDepositMsgsRequest")
	proto.RegisterType((*QueryPoolBatchDepositMsgRequest)(nil), "cyber.liquidity.v1beta1.QueryPoolBatchDepositMsgRequest")
	proto.RegisterType((*QueryPoolBatchDepositMsgsResponse)(nil), "cyber.liquidity.v1beta1.QueryPoolBatchDepositMsgsResponse")
	proto.RegisterType((*QueryPoolBatchDepositMsgResponse)(nil), "cyber.liquidity.v1beta1.QueryPoolBatchDepositMsgResponse")
	proto.RegisterType((*QueryPoolBatchWithdrawMsgsRequest)(nil), "cyber.liquidity.v1beta1.QueryPoolBatchWithdrawMsgsRequest")
	proto.RegisterType((*QueryPoolBatchWithdrawMsgRequest)(nil), "cyber.liquidity.v1beta1.QueryPoolBatchWithdrawMsgRequest")
	proto.RegisterType((*QueryPoolBatchWithdrawMsgsResponse)(nil), "cyber.liquidity.v1beta1.QueryPoolBatchWithdrawMsgsResponse")
	proto.RegisterType((*QueryPoolBatchWithdrawMsgResponse)(nil), "cyber.liquidity.v1beta1.QueryPoolBatchWithdrawMsgResponse")
}

func init() {
	proto.RegisterFile("cyber/liquidity/v1beta1/query.proto", fileDescriptor_456c121a8965f63a)
}

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

// Reference imports to suppress errors if they are not otherwise used.
var (
	_ context.Context
	_ 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 {
	// Get existing liquidity pools.
	LiquidityPools(ctx context.Context, in *QueryLiquidityPoolsRequest, opts ...grpc.CallOption) (*QueryLiquidityPoolsResponse, error)
	// Get specific liquidity pool.
	LiquidityPool(ctx context.Context, in *QueryLiquidityPoolRequest, opts ...grpc.CallOption) (*QueryLiquidityPoolResponse, error)
	// Get specific liquidity pool corresponding to the pool_coin_denom.
	LiquidityPoolByPoolCoinDenom(ctx context.Context, in *QueryLiquidityPoolByPoolCoinDenomRequest, opts ...grpc.CallOption) (*QueryLiquidityPoolResponse, error)
	// Get specific liquidity pool corresponding to the reserve account.
	LiquidityPoolByReserveAcc(ctx context.Context, in *QueryLiquidityPoolByReserveAccRequest, opts ...grpc.CallOption) (*QueryLiquidityPoolResponse, error)
	// Get the pool's current batch.
	LiquidityPoolBatch(ctx context.Context, in *QueryLiquidityPoolBatchRequest, opts ...grpc.CallOption) (*QueryLiquidityPoolBatchResponse, error)
	// Get all swap messages in the pool's current batch.
	PoolBatchSwapMsgs(ctx context.Context, in *QueryPoolBatchSwapMsgsRequest, opts ...grpc.CallOption) (*QueryPoolBatchSwapMsgsResponse, error)
	// Get a specific swap message in the pool's current batch.
	PoolBatchSwapMsg(ctx context.Context, in *QueryPoolBatchSwapMsgRequest, opts ...grpc.CallOption) (*QueryPoolBatchSwapMsgResponse, error)
	// Get all deposit messages in the pool's current batch.
	PoolBatchDepositMsgs(ctx context.Context, in *QueryPoolBatchDepositMsgsRequest, opts ...grpc.CallOption) (*QueryPoolBatchDepositMsgsResponse, error)
	// Get a specific deposit message in the pool's current batch.
	PoolBatchDepositMsg(ctx context.Context, in *QueryPoolBatchDepositMsgRequest, opts ...grpc.CallOption) (*QueryPoolBatchDepositMsgResponse, error)
	// Get all withdraw messages in the pool's current batch.
	PoolBatchWithdrawMsgs(ctx context.Context, in *QueryPoolBatchWithdrawMsgsRequest, opts ...grpc.CallOption) (*QueryPoolBatchWithdrawMsgsResponse, error)
	// Get a specific withdraw message in the pool's current batch.
	PoolBatchWithdrawMsg(ctx context.Context, in *QueryPoolBatchWithdrawMsgRequest, opts ...grpc.CallOption) (*QueryPoolBatchWithdrawMsgResponse, error)
	// Get all parameters of the liquidity module.
	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) LiquidityPools(ctx context.Context, in *QueryLiquidityPoolsRequest, opts ...grpc.CallOption) (*QueryLiquidityPoolsResponse, error) {
	out := new(QueryLiquidityPoolsResponse)
	err := c.cc.Invoke(ctx, "/cyber.liquidity.v1beta1.Query/LiquidityPools", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) LiquidityPool(ctx context.Context, in *QueryLiquidityPoolRequest, opts ...grpc.CallOption) (*QueryLiquidityPoolResponse, error) {
	out := new(QueryLiquidityPoolResponse)
	err := c.cc.Invoke(ctx, "/cyber.liquidity.v1beta1.Query/LiquidityPool", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) LiquidityPoolByPoolCoinDenom(ctx context.Context, in *QueryLiquidityPoolByPoolCoinDenomRequest, opts ...grpc.CallOption) (*QueryLiquidityPoolResponse, error) {
	out := new(QueryLiquidityPoolResponse)
	err := c.cc.Invoke(ctx, "/cyber.liquidity.v1beta1.Query/LiquidityPoolByPoolCoinDenom", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) LiquidityPoolByReserveAcc(ctx context.Context, in *QueryLiquidityPoolByReserveAccRequest, opts ...grpc.CallOption) (*QueryLiquidityPoolResponse, error) {
	out := new(QueryLiquidityPoolResponse)
	err := c.cc.Invoke(ctx, "/cyber.liquidity.v1beta1.Query/LiquidityPoolByReserveAcc", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) LiquidityPoolBatch(ctx context.Context, in *QueryLiquidityPoolBatchRequest, opts ...grpc.CallOption) (*QueryLiquidityPoolBatchResponse, error) {
	out := new(QueryLiquidityPoolBatchResponse)
	err := c.cc.Invoke(ctx, "/cyber.liquidity.v1beta1.Query/LiquidityPoolBatch", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) PoolBatchSwapMsgs(ctx context.Context, in *QueryPoolBatchSwapMsgsRequest, opts ...grpc.CallOption) (*QueryPoolBatchSwapMsgsResponse, error) {
	out := new(QueryPoolBatchSwapMsgsResponse)
	err := c.cc.Invoke(ctx, "/cyber.liquidity.v1beta1.Query/PoolBatchSwapMsgs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) PoolBatchSwapMsg(ctx context.Context, in *QueryPoolBatchSwapMsgRequest, opts ...grpc.CallOption) (*QueryPoolBatchSwapMsgResponse, error) {
	out := new(QueryPoolBatchSwapMsgResponse)
	err := c.cc.Invoke(ctx, "/cyber.liquidity.v1beta1.Query/PoolBatchSwapMsg", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) PoolBatchDepositMsgs(ctx context.Context, in *QueryPoolBatchDepositMsgsRequest, opts ...grpc.CallOption) (*QueryPoolBatchDepositMsgsResponse, error) {
	out := new(QueryPoolBatchDepositMsgsResponse)
	err := c.cc.Invoke(ctx, "/cyber.liquidity.v1beta1.Query/PoolBatchDepositMsgs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) PoolBatchDepositMsg(ctx context.Context, in *QueryPoolBatchDepositMsgRequest, opts ...grpc.CallOption) (*QueryPoolBatchDepositMsgResponse, error) {
	out := new(QueryPoolBatchDepositMsgResponse)
	err := c.cc.Invoke(ctx, "/cyber.liquidity.v1beta1.Query/PoolBatchDepositMsg", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) PoolBatchWithdrawMsgs(ctx context.Context, in *QueryPoolBatchWithdrawMsgsRequest, opts ...grpc.CallOption) (*QueryPoolBatchWithdrawMsgsResponse, error) {
	out := new(QueryPoolBatchWithdrawMsgsResponse)
	err := c.cc.Invoke(ctx, "/cyber.liquidity.v1beta1.Query/PoolBatchWithdrawMsgs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) PoolBatchWithdrawMsg(ctx context.Context, in *QueryPoolBatchWithdrawMsgRequest, opts ...grpc.CallOption) (*QueryPoolBatchWithdrawMsgResponse, error) {
	out := new(QueryPoolBatchWithdrawMsgResponse)
	err := c.cc.Invoke(ctx, "/cyber.liquidity.v1beta1.Query/PoolBatchWithdrawMsg", 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, "/cyber.liquidity.v1beta1.Query/Params", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// QueryServer is the server API for Query service.
type QueryServer interface {
	// Get existing liquidity pools.
	LiquidityPools(context.Context, *QueryLiquidityPoolsRequest) (*QueryLiquidityPoolsResponse, error)
	// Get specific liquidity pool.
	LiquidityPool(context.Context, *QueryLiquidityPoolRequest) (*QueryLiquidityPoolResponse, error)
	// Get specific liquidity pool corresponding to the pool_coin_denom.
	LiquidityPoolByPoolCoinDenom(context.Context, *QueryLiquidityPoolByPoolCoinDenomRequest) (*QueryLiquidityPoolResponse, error)
	// Get specific liquidity pool corresponding to the reserve account.
	LiquidityPoolByReserveAcc(context.Context, *QueryLiquidityPoolByReserveAccRequest) (*QueryLiquidityPoolResponse, error)
	// Get the pool's current batch.
	LiquidityPoolBatch(context.Context, *QueryLiquidityPoolBatchRequest) (*QueryLiquidityPoolBatchResponse, error)
	// Get all swap messages in the pool's current batch.
	PoolBatchSwapMsgs(context.Context, *QueryPoolBatchSwapMsgsRequest) (*QueryPoolBatchSwapMsgsResponse, error)
	// Get a specific swap message in the pool's current batch.
	PoolBatchSwapMsg(context.Context, *QueryPoolBatchSwapMsgRequest) (*QueryPoolBatchSwapMsgResponse, error)
	// Get all deposit messages in the pool's current batch.
	PoolBatchDepositMsgs(context.Context, *QueryPoolBatchDepositMsgsRequest) (*QueryPoolBatchDepositMsgsResponse, error)
	// Get a specific deposit message in the pool's current batch.
	PoolBatchDepositMsg(context.Context, *QueryPoolBatchDepositMsgRequest) (*QueryPoolBatchDepositMsgResponse, error)
	// Get all withdraw messages in the pool's current batch.
	PoolBatchWithdrawMsgs(context.Context, *QueryPoolBatchWithdrawMsgsRequest) (*QueryPoolBatchWithdrawMsgsResponse, error)
	// Get a specific withdraw message in the pool's current batch.
	PoolBatchWithdrawMsg(context.Context, *QueryPoolBatchWithdrawMsgRequest) (*QueryPoolBatchWithdrawMsgResponse, error)
	// Get all parameters of the liquidity module.
	Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error)
}

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

func (*UnimplementedQueryServer) LiquidityPools(ctx context.Context, req *QueryLiquidityPoolsRequest) (*QueryLiquidityPoolsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LiquidityPools not implemented")
}

func (*UnimplementedQueryServer) LiquidityPool(ctx context.Context, req *QueryLiquidityPoolRequest) (*QueryLiquidityPoolResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LiquidityPool not implemented")
}

func (*UnimplementedQueryServer) LiquidityPoolByPoolCoinDenom(ctx context.Context, req *QueryLiquidityPoolByPoolCoinDenomRequest) (*QueryLiquidityPoolResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LiquidityPoolByPoolCoinDenom not implemented")
}

func (*UnimplementedQueryServer) LiquidityPoolByReserveAcc(ctx context.Context, req *QueryLiquidityPoolByReserveAccRequest) (*QueryLiquidityPoolResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LiquidityPoolByReserveAcc not implemented")
}

func (*UnimplementedQueryServer) LiquidityPoolBatch(ctx context.Context, req *QueryLiquidityPoolBatchRequest) (*QueryLiquidityPoolBatchResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LiquidityPoolBatch not implemented")
}

func (*UnimplementedQueryServer) PoolBatchSwapMsgs(ctx context.Context, req *QueryPoolBatchSwapMsgsRequest) (*QueryPoolBatchSwapMsgsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PoolBatchSwapMsgs not implemented")
}

func (*UnimplementedQueryServer) PoolBatchSwapMsg(ctx context.Context, req *QueryPoolBatchSwapMsgRequest) (*QueryPoolBatchSwapMsgResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PoolBatchSwapMsg not implemented")
}

func (*UnimplementedQueryServer) PoolBatchDepositMsgs(ctx context.Context, req *QueryPoolBatchDepositMsgsRequest) (*QueryPoolBatchDepositMsgsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PoolBatchDepositMsgs not implemented")
}

func (*UnimplementedQueryServer) PoolBatchDepositMsg(ctx context.Context, req *QueryPoolBatchDepositMsgRequest) (*QueryPoolBatchDepositMsgResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PoolBatchDepositMsg not implemented")
}

func (*UnimplementedQueryServer) PoolBatchWithdrawMsgs(ctx context.Context, req *QueryPoolBatchWithdrawMsgsRequest) (*QueryPoolBatchWithdrawMsgsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PoolBatchWithdrawMsgs not implemented")
}

func (*UnimplementedQueryServer) PoolBatchWithdrawMsg(ctx context.Context, req *QueryPoolBatchWithdrawMsgRequest) (*QueryPoolBatchWithdrawMsgResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PoolBatchWithdrawMsg 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_LiquidityPools_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryLiquidityPoolsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).LiquidityPools(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cyber.liquidity.v1beta1.Query/LiquidityPools",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).LiquidityPools(ctx, req.(*QueryLiquidityPoolsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

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

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

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

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

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

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

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

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

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

func _Query_PoolBatchWithdrawMsg_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryPoolBatchWithdrawMsgRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).PoolBatchWithdrawMsg(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cyber.liquidity.v1beta1.Query/PoolBatchWithdrawMsg",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).PoolBatchWithdrawMsg(ctx, req.(*QueryPoolBatchWithdrawMsgRequest))
	}
	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: "/cyber.liquidity.v1beta1.Query/Params",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Params(ctx, req.(*QueryParamsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Query_serviceDesc = grpc.ServiceDesc{
	ServiceName: "cyber.liquidity.v1beta1.Query",
	HandlerType: (*QueryServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "LiquidityPools",
			Handler:    _Query_LiquidityPools_Handler,
		},
		{
			MethodName: "LiquidityPool",
			Handler:    _Query_LiquidityPool_Handler,
		},
		{
			MethodName: "LiquidityPoolByPoolCoinDenom",
			Handler:    _Query_LiquidityPoolByPoolCoinDenom_Handler,
		},
		{
			MethodName: "LiquidityPoolByReserveAcc",
			Handler:    _Query_LiquidityPoolByReserveAcc_Handler,
		},
		{
			MethodName: "LiquidityPoolBatch",
			Handler:    _Query_LiquidityPoolBatch_Handler,
		},
		{
			MethodName: "PoolBatchSwapMsgs",
			Handler:    _Query_PoolBatchSwapMsgs_Handler,
		},
		{
			MethodName: "PoolBatchSwapMsg",
			Handler:    _Query_PoolBatchSwapMsg_Handler,
		},
		{
			MethodName: "PoolBatchDepositMsgs",
			Handler:    _Query_PoolBatchDepositMsgs_Handler,
		},
		{
			MethodName: "PoolBatchDepositMsg",
			Handler:    _Query_PoolBatchDepositMsg_Handler,
		},
		{
			MethodName: "PoolBatchWithdrawMsgs",
			Handler:    _Query_PoolBatchWithdrawMsgs_Handler,
		},
		{
			MethodName: "PoolBatchWithdrawMsg",
			Handler:    _Query_PoolBatchWithdrawMsg_Handler,
		},
		{
			MethodName: "Params",
			Handler:    _Query_Params_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "cyber/liquidity/v1beta1/query.proto",
}

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *QueryPoolBatchSwapMsgsRequest) 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 m.PoolId != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.PoolId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *QueryPoolBatchDepositMsgsRequest) 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 m.PoolId != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.PoolId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *QueryPoolBatchWithdrawMsgsRequest) 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 m.PoolId != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.PoolId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *QueryPoolBatchWithdrawMsgsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Withdraws) > 0 {
		for _, e := range m.Withdraws {
			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 *QueryPoolBatchWithdrawMsgResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Withdraw.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 *QueryLiquidityPoolRequest) 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: QueryLiquidityPoolRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryLiquidityPoolRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PoolId", wireType)
			}
			m.PoolId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PoolId |= 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 *QueryLiquidityPoolResponse) 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: QueryLiquidityPoolResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryLiquidityPoolResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pool", 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.Pool.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 *QueryLiquidityPoolByPoolCoinDenomRequest) 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: QueryLiquidityPoolByPoolCoinDenomRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryLiquidityPoolByPoolCoinDenomRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PoolCoinDenom", 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.PoolCoinDenom = 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 *QueryLiquidityPoolByReserveAccRequest) 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: QueryLiquidityPoolByReserveAccRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryLiquidityPoolByReserveAccRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReserveAcc", 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.ReserveAcc = 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 *QueryLiquidityPoolBatchRequest) 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: QueryLiquidityPoolBatchRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryLiquidityPoolBatchRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PoolId", wireType)
			}
			m.PoolId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PoolId |= 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 *QueryLiquidityPoolBatchResponse) 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: QueryLiquidityPoolBatchResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryLiquidityPoolBatchResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Batch", 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.Batch.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 *QueryLiquidityPoolsRequest) 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: QueryLiquidityPoolsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryLiquidityPoolsRequest: 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 *QueryLiquidityPoolsResponse) 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: QueryLiquidityPoolsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryLiquidityPoolsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pools", 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.Pools = append(m.Pools, Pool{})
			if err := m.Pools[len(m.Pools)-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 *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 *QueryPoolBatchSwapMsgsRequest) 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: QueryPoolBatchSwapMsgsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryPoolBatchSwapMsgsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PoolId", wireType)
			}
			m.PoolId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PoolId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pagination == nil {
				m.Pagination = &query.PageRequest{}
			}
			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *QueryPoolBatchWithdrawMsgRequest) 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: QueryPoolBatchWithdrawMsgRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryPoolBatchWithdrawMsgRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PoolId", wireType)
			}
			m.PoolId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PoolId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MsgIndex", wireType)
			}
			m.MsgIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MsgIndex |= 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 *QueryPoolBatchWithdrawMsgsResponse) 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: QueryPoolBatchWithdrawMsgsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryPoolBatchWithdrawMsgsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Withdraws", 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.Withdraws = append(m.Withdraws, WithdrawMsgState{})
			if err := m.Withdraws[len(m.Withdraws)-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 *QueryPoolBatchWithdrawMsgResponse) 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: QueryPoolBatchWithdrawMsgResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryPoolBatchWithdrawMsgResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Withdraw", 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.Withdraw.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")
)