query.pb.go

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

package types

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

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

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

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

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

var xxx_messageInfo_QueryParamsRequest proto.InternalMessageInfo

// QueryParamsResponse is response type for the Query/Params RPC method.
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_d6c1b9fce48b6c34, []int{1}
}
func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryParamsResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryParamsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryParamsResponse.Merge(m, src)
}
func (m *QueryParamsResponse) XXX_Size() int {
	return m.Size()
}
func (m *QueryParamsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryParamsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryParamsResponse proto.InternalMessageInfo

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

// QueryParamsRequest is request type for the Query/Params RPC method.
type QueryNetworkParamsRequest struct {
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
}

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

var xxx_messageInfo_QueryNetworkParamsRequest proto.InternalMessageInfo

func (m *QueryNetworkParamsRequest) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

// QueryParamsResponse is response type for the Query/Params RPC method.
type QueryNetworkParamsResponse struct {
	Params Network `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
}

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

var xxx_messageInfo_QueryNetworkParamsResponse proto.InternalMessageInfo

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

type QueryGetItemRequest struct {
	Index string `protobuf:"bytes,1,opt,name=index,proto3" json:"index,omitempty"`
}

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

var xxx_messageInfo_QueryGetItemRequest proto.InternalMessageInfo

func (m *QueryGetItemRequest) GetIndex() string {
	if m != nil {
		return m.Index
	}
	return ""
}

type QueryGetItemResponse struct {
	Item Item `protobuf:"bytes,1,opt,name=item,proto3" json:"item"`
}

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

var xxx_messageInfo_QueryGetItemResponse proto.InternalMessageInfo

func (m *QueryGetItemResponse) GetItem() Item {
	if m != nil {
		return m.Item
	}
	return Item{}
}

type QueryGetItemByOnChainItemRequest struct {
	Chain   string `protobuf:"bytes,1,opt,name=chain,proto3" json:"chain,omitempty"`
	Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
	TokenID string `protobuf:"bytes,3,opt,name=tokenID,proto3" json:"tokenID,omitempty"`
}

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

var xxx_messageInfo_QueryGetItemByOnChainItemRequest proto.InternalMessageInfo

func (m *QueryGetItemByOnChainItemRequest) GetChain() string {
	if m != nil {
		return m.Chain
	}
	return ""
}

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

func (m *QueryGetItemByOnChainItemRequest) GetTokenID() string {
	if m != nil {
		return m.TokenID
	}
	return ""
}

type QueryGetItemByOnChainItemResponse struct {
	Item Item `protobuf:"bytes,1,opt,name=item,proto3" json:"item"`
}

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

var xxx_messageInfo_QueryGetItemByOnChainItemResponse proto.InternalMessageInfo

func (m *QueryGetItemByOnChainItemResponse) GetItem() Item {
	if m != nil {
		return m.Item
	}
	return Item{}
}

type QueryAllItemRequest struct {
	Pagination *query.PageRequest `protobuf:"bytes,3,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryAllItemRequest proto.InternalMessageInfo

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

type QueryAllItemResponse struct {
	Item       []Item              `protobuf:"bytes,1,rep,name=item,proto3" json:"item"`
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryAllItemResponse proto.InternalMessageInfo

func (m *QueryAllItemResponse) GetItem() []Item {
	if m != nil {
		return m.Item
	}
	return nil
}

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

type QueryGetOnChainItemRequest struct {
	Chain   string `protobuf:"bytes,1,opt,name=chain,proto3" json:"chain,omitempty"`
	Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
	TokenID string `protobuf:"bytes,3,opt,name=tokenID,proto3" json:"tokenID,omitempty"`
}

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

var xxx_messageInfo_QueryGetOnChainItemRequest proto.InternalMessageInfo

func (m *QueryGetOnChainItemRequest) GetChain() string {
	if m != nil {
		return m.Chain
	}
	return ""
}

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

func (m *QueryGetOnChainItemRequest) GetTokenID() string {
	if m != nil {
		return m.TokenID
	}
	return ""
}

type QueryGetOnChainItemResponse struct {
	Item OnChainItem `protobuf:"bytes,1,opt,name=item,proto3" json:"item"`
}

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

var xxx_messageInfo_QueryGetOnChainItemResponse proto.InternalMessageInfo

func (m *QueryGetOnChainItemResponse) GetItem() OnChainItem {
	if m != nil {
		return m.Item
	}
	return OnChainItem{}
}

type QueryGetOnChainItemByOtherRequest struct {
	Chain       string `protobuf:"bytes,1,opt,name=chain,proto3" json:"chain,omitempty"`
	Address     string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
	TokenID     string `protobuf:"bytes,3,opt,name=tokenID,proto3" json:"tokenID,omitempty"`
	TargetChain string `protobuf:"bytes,4,opt,name=targetChain,proto3" json:"targetChain,omitempty"`
}

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

var xxx_messageInfo_QueryGetOnChainItemByOtherRequest proto.InternalMessageInfo

func (m *QueryGetOnChainItemByOtherRequest) GetChain() string {
	if m != nil {
		return m.Chain
	}
	return ""
}

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

func (m *QueryGetOnChainItemByOtherRequest) GetTokenID() string {
	if m != nil {
		return m.TokenID
	}
	return ""
}

func (m *QueryGetOnChainItemByOtherRequest) GetTargetChain() string {
	if m != nil {
		return m.TargetChain
	}
	return ""
}

type QueryGetOnChainItemByOtherResponse struct {
	Item OnChainItem `protobuf:"bytes,1,opt,name=item,proto3" json:"item"`
}

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

var xxx_messageInfo_QueryGetOnChainItemByOtherResponse proto.InternalMessageInfo

func (m *QueryGetOnChainItemByOtherResponse) GetItem() OnChainItem {
	if m != nil {
		return m.Item
	}
	return OnChainItem{}
}

type QueryGetOnChainItemByItemForChainRequest struct {
	ItemIndex string `protobuf:"bytes,1,opt,name=item_index,json=itemIndex,proto3" json:"item_index,omitempty"`
	Chain     string `protobuf:"bytes,2,opt,name=chain,proto3" json:"chain,omitempty"`
}

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

var xxx_messageInfo_QueryGetOnChainItemByItemForChainRequest proto.InternalMessageInfo

func (m *QueryGetOnChainItemByItemForChainRequest) GetItemIndex() string {
	if m != nil {
		return m.ItemIndex
	}
	return ""
}

func (m *QueryGetOnChainItemByItemForChainRequest) GetChain() string {
	if m != nil {
		return m.Chain
	}
	return ""
}

type QueryGetOnChainItemByItemForChainResponse struct {
	Item OnChainItem `protobuf:"bytes,1,opt,name=item,proto3" json:"item"`
}

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

var xxx_messageInfo_QueryGetOnChainItemByItemForChainResponse proto.InternalMessageInfo

func (m *QueryGetOnChainItemByItemForChainResponse) GetItem() OnChainItem {
	if m != nil {
		return m.Item
	}
	return OnChainItem{}
}

type QueryAllOnChainItemRequest struct {
	Pagination *query.PageRequest `protobuf:"bytes,3,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryAllOnChainItemRequest proto.InternalMessageInfo

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

type QueryAllOnChainItemResponse struct {
	Item       []OnChainItem       `protobuf:"bytes,1,rep,name=item,proto3" json:"item"`
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryAllOnChainItemResponse proto.InternalMessageInfo

func (m *QueryAllOnChainItemResponse) GetItem() []OnChainItem {
	if m != nil {
		return m.Item
	}
	return nil
}

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

type QueryGetCollectionRequest struct {
	Index string `protobuf:"bytes,1,opt,name=index,proto3" json:"index,omitempty"`
}

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

var xxx_messageInfo_QueryGetCollectionRequest proto.InternalMessageInfo

func (m *QueryGetCollectionRequest) GetIndex() string {
	if m != nil {
		return m.Index
	}
	return ""
}

type QueryGetCollectionResponse struct {
	Collection Collection `protobuf:"bytes,1,opt,name=collection,proto3" json:"collection"`
}

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

var xxx_messageInfo_QueryGetCollectionResponse proto.InternalMessageInfo

func (m *QueryGetCollectionResponse) GetCollection() Collection {
	if m != nil {
		return m.Collection
	}
	return Collection{}
}

type QueryGetCollectionByCollectionDataRequest struct {
	Chain   string `protobuf:"bytes,1,opt,name=chain,proto3" json:"chain,omitempty"`
	Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
}

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

var xxx_messageInfo_QueryGetCollectionByCollectionDataRequest proto.InternalMessageInfo

func (m *QueryGetCollectionByCollectionDataRequest) GetChain() string {
	if m != nil {
		return m.Chain
	}
	return ""
}

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

type QueryGetCollectionByCollectionDataResponse struct {
	Collection Collection `protobuf:"bytes,1,opt,name=collection,proto3" json:"collection"`
}

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

var xxx_messageInfo_QueryGetCollectionByCollectionDataResponse proto.InternalMessageInfo

func (m *QueryGetCollectionByCollectionDataResponse) GetCollection() Collection {
	if m != nil {
		return m.Collection
	}
	return Collection{}
}

type QueryAllCollectionRequest struct {
	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryAllCollectionRequest proto.InternalMessageInfo

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

type QueryAllCollectionResponse struct {
	Collection []Collection        `protobuf:"bytes,1,rep,name=collection,proto3" json:"collection"`
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryAllCollectionResponse proto.InternalMessageInfo

func (m *QueryAllCollectionResponse) GetCollection() []Collection {
	if m != nil {
		return m.Collection
	}
	return nil
}

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

type QueryGetCollectionDataRequest struct {
	Chain   string `protobuf:"bytes,1,opt,name=chain,proto3" json:"chain,omitempty"`
	Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
}

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

var xxx_messageInfo_QueryGetCollectionDataRequest proto.InternalMessageInfo

func (m *QueryGetCollectionDataRequest) GetChain() string {
	if m != nil {
		return m.Chain
	}
	return ""
}

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

type QueryGetCollectionDataResponse struct {
	Data CollectionData `protobuf:"bytes,1,opt,name=data,proto3" json:"data"`
}

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

var xxx_messageInfo_QueryGetCollectionDataResponse proto.InternalMessageInfo

func (m *QueryGetCollectionDataResponse) GetData() CollectionData {
	if m != nil {
		return m.Data
	}
	return CollectionData{}
}

type QueryGetCollectionDataByCollectionForChainRequest struct {
	CollectionIndex string `protobuf:"bytes,1,opt,name=collection_index,json=collectionIndex,proto3" json:"collection_index,omitempty"`
	Chain           string `protobuf:"bytes,2,opt,name=chain,proto3" json:"chain,omitempty"`
}

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

var xxx_messageInfo_QueryGetCollectionDataByCollectionForChainRequest proto.InternalMessageInfo

func (m *QueryGetCollectionDataByCollectionForChainRequest) GetCollectionIndex() string {
	if m != nil {
		return m.CollectionIndex
	}
	return ""
}

func (m *QueryGetCollectionDataByCollectionForChainRequest) GetChain() string {
	if m != nil {
		return m.Chain
	}
	return ""
}

type QueryGetCollectionDataByCollectionForChainResponse struct {
	Data CollectionData `protobuf:"bytes,1,opt,name=data,proto3" json:"data"`
}

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

var xxx_messageInfo_QueryGetCollectionDataByCollectionForChainResponse proto.InternalMessageInfo

func (m *QueryGetCollectionDataByCollectionForChainResponse) GetData() CollectionData {
	if m != nil {
		return m.Data
	}
	return CollectionData{}
}

type QueryGetNativeCollectionDataRequest struct {
	Collection string `protobuf:"bytes,1,opt,name=collection,proto3" json:"collection,omitempty"`
}

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

var xxx_messageInfo_QueryGetNativeCollectionDataRequest proto.InternalMessageInfo

func (m *QueryGetNativeCollectionDataRequest) GetCollection() string {
	if m != nil {
		return m.Collection
	}
	return ""
}

type QueryGetNativeCollectionDataResponse struct {
	Data CollectionData `protobuf:"bytes,1,opt,name=data,proto3" json:"data"`
}

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

var xxx_messageInfo_QueryGetNativeCollectionDataResponse proto.InternalMessageInfo

func (m *QueryGetNativeCollectionDataResponse) GetData() CollectionData {
	if m != nil {
		return m.Data
	}
	return CollectionData{}
}

type QueryAllCollectionDataRequest struct {
	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryAllCollectionDataRequest proto.InternalMessageInfo

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

type QueryAllCollectionDataResponse struct {
	Data       []CollectionData    `protobuf:"bytes,1,rep,name=data,proto3" json:"data"`
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryAllCollectionDataResponse proto.InternalMessageInfo

func (m *QueryAllCollectionDataResponse) GetData() []CollectionData {
	if m != nil {
		return m.Data
	}
	return nil
}

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

type QueryGetSeedRequest struct {
	Seed string `protobuf:"bytes,1,opt,name=seed,proto3" json:"seed,omitempty"`
}

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

var xxx_messageInfo_QueryGetSeedRequest proto.InternalMessageInfo

func (m *QueryGetSeedRequest) GetSeed() string {
	if m != nil {
		return m.Seed
	}
	return ""
}

type QueryGetSeedResponse struct {
	Seed Seed `protobuf:"bytes,1,opt,name=seed,proto3" json:"seed"`
}

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

var xxx_messageInfo_QueryGetSeedResponse proto.InternalMessageInfo

func (m *QueryGetSeedResponse) GetSeed() Seed {
	if m != nil {
		return m.Seed
	}
	return Seed{}
}

type QueryAllSeedRequest struct {
	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryAllSeedRequest proto.InternalMessageInfo

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

type QueryAllSeedResponse struct {
	Seed       []Seed              `protobuf:"bytes,1,rep,name=seed,proto3" json:"seed"`
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryAllSeedResponse proto.InternalMessageInfo

func (m *QueryAllSeedResponse) GetSeed() []Seed {
	if m != nil {
		return m.Seed
	}
	return nil
}

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

func init() {
	proto.RegisterType((*QueryParamsRequest)(nil), "rarimo.rarimocore.tokenmanager.QueryParamsRequest")
	proto.RegisterType((*QueryParamsResponse)(nil), "rarimo.rarimocore.tokenmanager.QueryParamsResponse")
	proto.RegisterType((*QueryNetworkParamsRequest)(nil), "rarimo.rarimocore.tokenmanager.QueryNetworkParamsRequest")
	proto.RegisterType((*QueryNetworkParamsResponse)(nil), "rarimo.rarimocore.tokenmanager.QueryNetworkParamsResponse")
	proto.RegisterType((*QueryGetItemRequest)(nil), "rarimo.rarimocore.tokenmanager.QueryGetItemRequest")
	proto.RegisterType((*QueryGetItemResponse)(nil), "rarimo.rarimocore.tokenmanager.QueryGetItemResponse")
	proto.RegisterType((*QueryGetItemByOnChainItemRequest)(nil), "rarimo.rarimocore.tokenmanager.QueryGetItemByOnChainItemRequest")
	proto.RegisterType((*QueryGetItemByOnChainItemResponse)(nil), "rarimo.rarimocore.tokenmanager.QueryGetItemByOnChainItemResponse")
	proto.RegisterType((*QueryAllItemRequest)(nil), "rarimo.rarimocore.tokenmanager.QueryAllItemRequest")
	proto.RegisterType((*QueryAllItemResponse)(nil), "rarimo.rarimocore.tokenmanager.QueryAllItemResponse")
	proto.RegisterType((*QueryGetOnChainItemRequest)(nil), "rarimo.rarimocore.tokenmanager.QueryGetOnChainItemRequest")
	proto.RegisterType((*QueryGetOnChainItemResponse)(nil), "rarimo.rarimocore.tokenmanager.QueryGetOnChainItemResponse")
	proto.RegisterType((*QueryGetOnChainItemByOtherRequest)(nil), "rarimo.rarimocore.tokenmanager.QueryGetOnChainItemByOtherRequest")
	proto.RegisterType((*QueryGetOnChainItemByOtherResponse)(nil), "rarimo.rarimocore.tokenmanager.QueryGetOnChainItemByOtherResponse")
	proto.RegisterType((*QueryGetOnChainItemByItemForChainRequest)(nil), "rarimo.rarimocore.tokenmanager.QueryGetOnChainItemByItemForChainRequest")
	proto.RegisterType((*QueryGetOnChainItemByItemForChainResponse)(nil), "rarimo.rarimocore.tokenmanager.QueryGetOnChainItemByItemForChainResponse")
	proto.RegisterType((*QueryAllOnChainItemRequest)(nil), "rarimo.rarimocore.tokenmanager.QueryAllOnChainItemRequest")
	proto.RegisterType((*QueryAllOnChainItemResponse)(nil), "rarimo.rarimocore.tokenmanager.QueryAllOnChainItemResponse")
	proto.RegisterType((*QueryGetCollectionRequest)(nil), "rarimo.rarimocore.tokenmanager.QueryGetCollectionRequest")
	proto.RegisterType((*QueryGetCollectionResponse)(nil), "rarimo.rarimocore.tokenmanager.QueryGetCollectionResponse")
	proto.RegisterType((*QueryGetCollectionByCollectionDataRequest)(nil), "rarimo.rarimocore.tokenmanager.QueryGetCollectionByCollectionDataRequest")
	proto.RegisterType((*QueryGetCollectionByCollectionDataResponse)(nil), "rarimo.rarimocore.tokenmanager.QueryGetCollectionByCollectionDataResponse")
	proto.RegisterType((*QueryAllCollectionRequest)(nil), "rarimo.rarimocore.tokenmanager.QueryAllCollectionRequest")
	proto.RegisterType((*QueryAllCollectionResponse)(nil), "rarimo.rarimocore.tokenmanager.QueryAllCollectionResponse")
	proto.RegisterType((*QueryGetCollectionDataRequest)(nil), "rarimo.rarimocore.tokenmanager.QueryGetCollectionDataRequest")
	proto.RegisterType((*QueryGetCollectionDataResponse)(nil), "rarimo.rarimocore.tokenmanager.QueryGetCollectionDataResponse")
	proto.RegisterType((*QueryGetCollectionDataByCollectionForChainRequest)(nil), "rarimo.rarimocore.tokenmanager.QueryGetCollectionDataByCollectionForChainRequest")
	proto.RegisterType((*QueryGetCollectionDataByCollectionForChainResponse)(nil), "rarimo.rarimocore.tokenmanager.QueryGetCollectionDataByCollectionForChainResponse")
	proto.RegisterType((*QueryGetNativeCollectionDataRequest)(nil), "rarimo.rarimocore.tokenmanager.QueryGetNativeCollectionDataRequest")
	proto.RegisterType((*QueryGetNativeCollectionDataResponse)(nil), "rarimo.rarimocore.tokenmanager.QueryGetNativeCollectionDataResponse")
	proto.RegisterType((*QueryAllCollectionDataRequest)(nil), "rarimo.rarimocore.tokenmanager.QueryAllCollectionDataRequest")
	proto.RegisterType((*QueryAllCollectionDataResponse)(nil), "rarimo.rarimocore.tokenmanager.QueryAllCollectionDataResponse")
	proto.RegisterType((*QueryGetSeedRequest)(nil), "rarimo.rarimocore.tokenmanager.QueryGetSeedRequest")
	proto.RegisterType((*QueryGetSeedResponse)(nil), "rarimo.rarimocore.tokenmanager.QueryGetSeedResponse")
	proto.RegisterType((*QueryAllSeedRequest)(nil), "rarimo.rarimocore.tokenmanager.QueryAllSeedRequest")
	proto.RegisterType((*QueryAllSeedResponse)(nil), "rarimo.rarimocore.tokenmanager.QueryAllSeedResponse")
}

func init() { proto.RegisterFile("tokenmanager/query.proto", fileDescriptor_d6c1b9fce48b6c34) }

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

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

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

// QueryClient is the client API for Query service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type QueryClient interface {
	// Parameters queries the parameters of the module.
	Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error)
	// Parameters queries the parameters of the module.
	NetworkParams(ctx context.Context, in *QueryNetworkParamsRequest, opts ...grpc.CallOption) (*QueryNetworkParamsResponse, error)
	// Queries a Item by index.
	Item(ctx context.Context, in *QueryGetItemRequest, opts ...grpc.CallOption) (*QueryGetItemResponse, error)
	// Queries a Item by index.
	ItemByOnChainItem(ctx context.Context, in *QueryGetItemByOnChainItemRequest, opts ...grpc.CallOption) (*QueryGetItemByOnChainItemResponse, error)
	// Queries a list of Item entries.
	ItemAll(ctx context.Context, in *QueryAllItemRequest, opts ...grpc.CallOption) (*QueryAllItemResponse, error)
	// Queries a Item by index.
	OnChainItem(ctx context.Context, in *QueryGetOnChainItemRequest, opts ...grpc.CallOption) (*QueryGetOnChainItemResponse, error)
	// Queries a Item by index.
	OnChainItemByOther(ctx context.Context, in *QueryGetOnChainItemByOtherRequest, opts ...grpc.CallOption) (*QueryGetOnChainItemByOtherResponse, error)
	OnChainItemByItemForChain(ctx context.Context, in *QueryGetOnChainItemByItemForChainRequest, opts ...grpc.CallOption) (*QueryGetOnChainItemByItemForChainResponse, error)
	// Queries a list of Item entries.
	OnChainItemAll(ctx context.Context, in *QueryAllOnChainItemRequest, opts ...grpc.CallOption) (*QueryAllOnChainItemResponse, error)
	Collection(ctx context.Context, in *QueryGetCollectionRequest, opts ...grpc.CallOption) (*QueryGetCollectionResponse, error)
	CollectionByCollectionData(ctx context.Context, in *QueryGetCollectionByCollectionDataRequest, opts ...grpc.CallOption) (*QueryGetCollectionByCollectionDataResponse, error)
	CollectionAll(ctx context.Context, in *QueryAllCollectionRequest, opts ...grpc.CallOption) (*QueryAllCollectionResponse, error)
	CollectionData(ctx context.Context, in *QueryGetCollectionDataRequest, opts ...grpc.CallOption) (*QueryGetCollectionDataResponse, error)
	CollectionDataByCollectionForChain(ctx context.Context, in *QueryGetCollectionDataByCollectionForChainRequest, opts ...grpc.CallOption) (*QueryGetCollectionDataByCollectionForChainResponse, error)
	NativeCollectionData(ctx context.Context, in *QueryGetNativeCollectionDataRequest, opts ...grpc.CallOption) (*QueryGetNativeCollectionDataResponse, error)
	CollectionDataAll(ctx context.Context, in *QueryAllCollectionDataRequest, opts ...grpc.CallOption) (*QueryAllCollectionDataResponse, error)
	Seed(ctx context.Context, in *QueryGetSeedRequest, opts ...grpc.CallOption) (*QueryGetSeedResponse, error)
	SeedAll(ctx context.Context, in *QueryAllSeedRequest, opts ...grpc.CallOption) (*QueryAllSeedResponse, error)
}

type queryClient struct {
	cc grpc1.ClientConn
}

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

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

func (c *queryClient) NetworkParams(ctx context.Context, in *QueryNetworkParamsRequest, opts ...grpc.CallOption) (*QueryNetworkParamsResponse, error) {
	out := new(QueryNetworkParamsResponse)
	err := c.cc.Invoke(ctx, "/rarimo.rarimocore.tokenmanager.Query/NetworkParams", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) Item(ctx context.Context, in *QueryGetItemRequest, opts ...grpc.CallOption) (*QueryGetItemResponse, error) {
	out := new(QueryGetItemResponse)
	err := c.cc.Invoke(ctx, "/rarimo.rarimocore.tokenmanager.Query/Item", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) ItemByOnChainItem(ctx context.Context, in *QueryGetItemByOnChainItemRequest, opts ...grpc.CallOption) (*QueryGetItemByOnChainItemResponse, error) {
	out := new(QueryGetItemByOnChainItemResponse)
	err := c.cc.Invoke(ctx, "/rarimo.rarimocore.tokenmanager.Query/ItemByOnChainItem", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) ItemAll(ctx context.Context, in *QueryAllItemRequest, opts ...grpc.CallOption) (*QueryAllItemResponse, error) {
	out := new(QueryAllItemResponse)
	err := c.cc.Invoke(ctx, "/rarimo.rarimocore.tokenmanager.Query/ItemAll", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) OnChainItem(ctx context.Context, in *QueryGetOnChainItemRequest, opts ...grpc.CallOption) (*QueryGetOnChainItemResponse, error) {
	out := new(QueryGetOnChainItemResponse)
	err := c.cc.Invoke(ctx, "/rarimo.rarimocore.tokenmanager.Query/OnChainItem", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) OnChainItemByOther(ctx context.Context, in *QueryGetOnChainItemByOtherRequest, opts ...grpc.CallOption) (*QueryGetOnChainItemByOtherResponse, error) {
	out := new(QueryGetOnChainItemByOtherResponse)
	err := c.cc.Invoke(ctx, "/rarimo.rarimocore.tokenmanager.Query/OnChainItemByOther", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) OnChainItemByItemForChain(ctx context.Context, in *QueryGetOnChainItemByItemForChainRequest, opts ...grpc.CallOption) (*QueryGetOnChainItemByItemForChainResponse, error) {
	out := new(QueryGetOnChainItemByItemForChainResponse)
	err := c.cc.Invoke(ctx, "/rarimo.rarimocore.tokenmanager.Query/OnChainItemByItemForChain", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) OnChainItemAll(ctx context.Context, in *QueryAllOnChainItemRequest, opts ...grpc.CallOption) (*QueryAllOnChainItemResponse, error) {
	out := new(QueryAllOnChainItemResponse)
	err := c.cc.Invoke(ctx, "/rarimo.rarimocore.tokenmanager.Query/OnChainItemAll", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) Collection(ctx context.Context, in *QueryGetCollectionRequest, opts ...grpc.CallOption) (*QueryGetCollectionResponse, error) {
	out := new(QueryGetCollectionResponse)
	err := c.cc.Invoke(ctx, "/rarimo.rarimocore.tokenmanager.Query/Collection", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) CollectionByCollectionData(ctx context.Context, in *QueryGetCollectionByCollectionDataRequest, opts ...grpc.CallOption) (*QueryGetCollectionByCollectionDataResponse, error) {
	out := new(QueryGetCollectionByCollectionDataResponse)
	err := c.cc.Invoke(ctx, "/rarimo.rarimocore.tokenmanager.Query/CollectionByCollectionData", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) CollectionAll(ctx context.Context, in *QueryAllCollectionRequest, opts ...grpc.CallOption) (*QueryAllCollectionResponse, error) {
	out := new(QueryAllCollectionResponse)
	err := c.cc.Invoke(ctx, "/rarimo.rarimocore.tokenmanager.Query/CollectionAll", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) CollectionData(ctx context.Context, in *QueryGetCollectionDataRequest, opts ...grpc.CallOption) (*QueryGetCollectionDataResponse, error) {
	out := new(QueryGetCollectionDataResponse)
	err := c.cc.Invoke(ctx, "/rarimo.rarimocore.tokenmanager.Query/CollectionData", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) CollectionDataByCollectionForChain(ctx context.Context, in *QueryGetCollectionDataByCollectionForChainRequest, opts ...grpc.CallOption) (*QueryGetCollectionDataByCollectionForChainResponse, error) {
	out := new(QueryGetCollectionDataByCollectionForChainResponse)
	err := c.cc.Invoke(ctx, "/rarimo.rarimocore.tokenmanager.Query/CollectionDataByCollectionForChain", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) NativeCollectionData(ctx context.Context, in *QueryGetNativeCollectionDataRequest, opts ...grpc.CallOption) (*QueryGetNativeCollectionDataResponse, error) {
	out := new(QueryGetNativeCollectionDataResponse)
	err := c.cc.Invoke(ctx, "/rarimo.rarimocore.tokenmanager.Query/NativeCollectionData", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) CollectionDataAll(ctx context.Context, in *QueryAllCollectionDataRequest, opts ...grpc.CallOption) (*QueryAllCollectionDataResponse, error) {
	out := new(QueryAllCollectionDataResponse)
	err := c.cc.Invoke(ctx, "/rarimo.rarimocore.tokenmanager.Query/CollectionDataAll", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) Seed(ctx context.Context, in *QueryGetSeedRequest, opts ...grpc.CallOption) (*QueryGetSeedResponse, error) {
	out := new(QueryGetSeedResponse)
	err := c.cc.Invoke(ctx, "/rarimo.rarimocore.tokenmanager.Query/Seed", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) SeedAll(ctx context.Context, in *QueryAllSeedRequest, opts ...grpc.CallOption) (*QueryAllSeedResponse, error) {
	out := new(QueryAllSeedResponse)
	err := c.cc.Invoke(ctx, "/rarimo.rarimocore.tokenmanager.Query/SeedAll", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// QueryServer is the server API for Query service.
type QueryServer interface {
	// Parameters queries the parameters of the module.
	Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error)
	// Parameters queries the parameters of the module.
	NetworkParams(context.Context, *QueryNetworkParamsRequest) (*QueryNetworkParamsResponse, error)
	// Queries a Item by index.
	Item(context.Context, *QueryGetItemRequest) (*QueryGetItemResponse, error)
	// Queries a Item by index.
	ItemByOnChainItem(context.Context, *QueryGetItemByOnChainItemRequest) (*QueryGetItemByOnChainItemResponse, error)
	// Queries a list of Item entries.
	ItemAll(context.Context, *QueryAllItemRequest) (*QueryAllItemResponse, error)
	// Queries a Item by index.
	OnChainItem(context.Context, *QueryGetOnChainItemRequest) (*QueryGetOnChainItemResponse, error)
	// Queries a Item by index.
	OnChainItemByOther(context.Context, *QueryGetOnChainItemByOtherRequest) (*QueryGetOnChainItemByOtherResponse, error)
	OnChainItemByItemForChain(context.Context, *QueryGetOnChainItemByItemForChainRequest) (*QueryGetOnChainItemByItemForChainResponse, error)
	// Queries a list of Item entries.
	OnChainItemAll(context.Context, *QueryAllOnChainItemRequest) (*QueryAllOnChainItemResponse, error)
	Collection(context.Context, *QueryGetCollectionRequest) (*QueryGetCollectionResponse, error)
	CollectionByCollectionData(context.Context, *QueryGetCollectionByCollectionDataRequest) (*QueryGetCollectionByCollectionDataResponse, error)
	CollectionAll(context.Context, *QueryAllCollectionRequest) (*QueryAllCollectionResponse, error)
	CollectionData(context.Context, *QueryGetCollectionDataRequest) (*QueryGetCollectionDataResponse, error)
	CollectionDataByCollectionForChain(context.Context, *QueryGetCollectionDataByCollectionForChainRequest) (*QueryGetCollectionDataByCollectionForChainResponse, error)
	NativeCollectionData(context.Context, *QueryGetNativeCollectionDataRequest) (*QueryGetNativeCollectionDataResponse, error)
	CollectionDataAll(context.Context, *QueryAllCollectionDataRequest) (*QueryAllCollectionDataResponse, error)
	Seed(context.Context, *QueryGetSeedRequest) (*QueryGetSeedResponse, error)
	SeedAll(context.Context, *QueryAllSeedRequest) (*QueryAllSeedResponse, error)
}

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

func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Params not implemented")
}
func (*UnimplementedQueryServer) NetworkParams(ctx context.Context, req *QueryNetworkParamsRequest) (*QueryNetworkParamsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method NetworkParams not implemented")
}
func (*UnimplementedQueryServer) Item(ctx context.Context, req *QueryGetItemRequest) (*QueryGetItemResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Item not implemented")
}
func (*UnimplementedQueryServer) ItemByOnChainItem(ctx context.Context, req *QueryGetItemByOnChainItemRequest) (*QueryGetItemByOnChainItemResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ItemByOnChainItem not implemented")
}
func (*UnimplementedQueryServer) ItemAll(ctx context.Context, req *QueryAllItemRequest) (*QueryAllItemResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ItemAll not implemented")
}
func (*UnimplementedQueryServer) OnChainItem(ctx context.Context, req *QueryGetOnChainItemRequest) (*QueryGetOnChainItemResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method OnChainItem not implemented")
}
func (*UnimplementedQueryServer) OnChainItemByOther(ctx context.Context, req *QueryGetOnChainItemByOtherRequest) (*QueryGetOnChainItemByOtherResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method OnChainItemByOther not implemented")
}
func (*UnimplementedQueryServer) OnChainItemByItemForChain(ctx context.Context, req *QueryGetOnChainItemByItemForChainRequest) (*QueryGetOnChainItemByItemForChainResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method OnChainItemByItemForChain not implemented")
}
func (*UnimplementedQueryServer) OnChainItemAll(ctx context.Context, req *QueryAllOnChainItemRequest) (*QueryAllOnChainItemResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method OnChainItemAll not implemented")
}
func (*UnimplementedQueryServer) Collection(ctx context.Context, req *QueryGetCollectionRequest) (*QueryGetCollectionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Collection not implemented")
}
func (*UnimplementedQueryServer) CollectionByCollectionData(ctx context.Context, req *QueryGetCollectionByCollectionDataRequest) (*QueryGetCollectionByCollectionDataResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CollectionByCollectionData not implemented")
}
func (*UnimplementedQueryServer) CollectionAll(ctx context.Context, req *QueryAllCollectionRequest) (*QueryAllCollectionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CollectionAll not implemented")
}
func (*UnimplementedQueryServer) CollectionData(ctx context.Context, req *QueryGetCollectionDataRequest) (*QueryGetCollectionDataResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CollectionData not implemented")
}
func (*UnimplementedQueryServer) CollectionDataByCollectionForChain(ctx context.Context, req *QueryGetCollectionDataByCollectionForChainRequest) (*QueryGetCollectionDataByCollectionForChainResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CollectionDataByCollectionForChain not implemented")
}
func (*UnimplementedQueryServer) NativeCollectionData(ctx context.Context, req *QueryGetNativeCollectionDataRequest) (*QueryGetNativeCollectionDataResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method NativeCollectionData not implemented")
}
func (*UnimplementedQueryServer) CollectionDataAll(ctx context.Context, req *QueryAllCollectionDataRequest) (*QueryAllCollectionDataResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CollectionDataAll not implemented")
}
func (*UnimplementedQueryServer) Seed(ctx context.Context, req *QueryGetSeedRequest) (*QueryGetSeedResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Seed not implemented")
}
func (*UnimplementedQueryServer) SeedAll(ctx context.Context, req *QueryAllSeedRequest) (*QueryAllSeedResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SeedAll not implemented")
}

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

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

func _Query_NetworkParams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryNetworkParamsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).NetworkParams(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rarimo.rarimocore.tokenmanager.Query/NetworkParams",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).NetworkParams(ctx, req.(*QueryNetworkParamsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_Item_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryGetItemRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Item(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rarimo.rarimocore.tokenmanager.Query/Item",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Item(ctx, req.(*QueryGetItemRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_ItemByOnChainItem_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryGetItemByOnChainItemRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).ItemByOnChainItem(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rarimo.rarimocore.tokenmanager.Query/ItemByOnChainItem",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).ItemByOnChainItem(ctx, req.(*QueryGetItemByOnChainItemRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_ItemAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryAllItemRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).ItemAll(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rarimo.rarimocore.tokenmanager.Query/ItemAll",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).ItemAll(ctx, req.(*QueryAllItemRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_OnChainItem_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryGetOnChainItemRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).OnChainItem(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rarimo.rarimocore.tokenmanager.Query/OnChainItem",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).OnChainItem(ctx, req.(*QueryGetOnChainItemRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_OnChainItemByOther_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryGetOnChainItemByOtherRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).OnChainItemByOther(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rarimo.rarimocore.tokenmanager.Query/OnChainItemByOther",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).OnChainItemByOther(ctx, req.(*QueryGetOnChainItemByOtherRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_OnChainItemByItemForChain_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryGetOnChainItemByItemForChainRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).OnChainItemByItemForChain(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rarimo.rarimocore.tokenmanager.Query/OnChainItemByItemForChain",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).OnChainItemByItemForChain(ctx, req.(*QueryGetOnChainItemByItemForChainRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_OnChainItemAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryAllOnChainItemRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).OnChainItemAll(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rarimo.rarimocore.tokenmanager.Query/OnChainItemAll",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).OnChainItemAll(ctx, req.(*QueryAllOnChainItemRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_Collection_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryGetCollectionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Collection(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rarimo.rarimocore.tokenmanager.Query/Collection",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Collection(ctx, req.(*QueryGetCollectionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_CollectionByCollectionData_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryGetCollectionByCollectionDataRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).CollectionByCollectionData(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rarimo.rarimocore.tokenmanager.Query/CollectionByCollectionData",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).CollectionByCollectionData(ctx, req.(*QueryGetCollectionByCollectionDataRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_CollectionAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryAllCollectionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).CollectionAll(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rarimo.rarimocore.tokenmanager.Query/CollectionAll",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).CollectionAll(ctx, req.(*QueryAllCollectionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_CollectionData_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryGetCollectionDataRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).CollectionData(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rarimo.rarimocore.tokenmanager.Query/CollectionData",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).CollectionData(ctx, req.(*QueryGetCollectionDataRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_CollectionDataByCollectionForChain_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryGetCollectionDataByCollectionForChainRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).CollectionDataByCollectionForChain(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rarimo.rarimocore.tokenmanager.Query/CollectionDataByCollectionForChain",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).CollectionDataByCollectionForChain(ctx, req.(*QueryGetCollectionDataByCollectionForChainRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_NativeCollectionData_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryGetNativeCollectionDataRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).NativeCollectionData(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rarimo.rarimocore.tokenmanager.Query/NativeCollectionData",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).NativeCollectionData(ctx, req.(*QueryGetNativeCollectionDataRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_CollectionDataAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryAllCollectionDataRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).CollectionDataAll(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rarimo.rarimocore.tokenmanager.Query/CollectionDataAll",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).CollectionDataAll(ctx, req.(*QueryAllCollectionDataRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_Seed_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryGetSeedRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Seed(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rarimo.rarimocore.tokenmanager.Query/Seed",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Seed(ctx, req.(*QueryGetSeedRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_SeedAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryAllSeedRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).SeedAll(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rarimo.rarimocore.tokenmanager.Query/SeedAll",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).SeedAll(ctx, req.(*QueryAllSeedRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Query_serviceDesc = grpc.ServiceDesc{
	ServiceName: "rarimo.rarimocore.tokenmanager.Query",
	HandlerType: (*QueryServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Params",
			Handler:    _Query_Params_Handler,
		},
		{
			MethodName: "NetworkParams",
			Handler:    _Query_NetworkParams_Handler,
		},
		{
			MethodName: "Item",
			Handler:    _Query_Item_Handler,
		},
		{
			MethodName: "ItemByOnChainItem",
			Handler:    _Query_ItemByOnChainItem_Handler,
		},
		{
			MethodName: "ItemAll",
			Handler:    _Query_ItemAll_Handler,
		},
		{
			MethodName: "OnChainItem",
			Handler:    _Query_OnChainItem_Handler,
		},
		{
			MethodName: "OnChainItemByOther",
			Handler:    _Query_OnChainItemByOther_Handler,
		},
		{
			MethodName: "OnChainItemByItemForChain",
			Handler:    _Query_OnChainItemByItemForChain_Handler,
		},
		{
			MethodName: "OnChainItemAll",
			Handler:    _Query_OnChainItemAll_Handler,
		},
		{
			MethodName: "Collection",
			Handler:    _Query_Collection_Handler,
		},
		{
			MethodName: "CollectionByCollectionData",
			Handler:    _Query_CollectionByCollectionData_Handler,
		},
		{
			MethodName: "CollectionAll",
			Handler:    _Query_CollectionAll_Handler,
		},
		{
			MethodName: "CollectionData",
			Handler:    _Query_CollectionData_Handler,
		},
		{
			MethodName: "CollectionDataByCollectionForChain",
			Handler:    _Query_CollectionDataByCollectionForChain_Handler,
		},
		{
			MethodName: "NativeCollectionData",
			Handler:    _Query_NativeCollectionData_Handler,
		},
		{
			MethodName: "CollectionDataAll",
			Handler:    _Query_CollectionDataAll_Handler,
		},
		{
			MethodName: "Seed",
			Handler:    _Query_Seed_Handler,
		},
		{
			MethodName: "SeedAll",
			Handler:    _Query_SeedAll_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "tokenmanager/query.proto",
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *QueryAllSeedResponse) 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.Seed) > 0 {
		for iNdEx := len(m.Seed) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Seed[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQuery(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func encodeVarintQuery(dAtA []byte, offset int, v uint64) int {
	offset -= sovQuery(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *QueryParamsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

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

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

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

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

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

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

func (m *QueryAllItemRequest) 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 *QueryAllItemResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Item) > 0 {
		for _, e := range m.Item {
			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 *QueryGetOnChainItemRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Chain)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.TokenID)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

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

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

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

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

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

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

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

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

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

func (m *QueryAllCollectionRequest) 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 *QueryAllCollectionResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Collection) > 0 {
		for _, e := range m.Collection {
			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 *QueryGetCollectionDataRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Chain)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

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

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

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

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

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

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryNetworkParamsRequest) 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: QueryNetworkParamsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryNetworkParamsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", 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.Name = 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 *QueryNetworkParamsResponse) 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: QueryNetworkParamsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryNetworkParamsResponse: 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 *QueryGetItemRequest) 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: QueryGetItemRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGetItemRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", 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.Index = 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 *QueryGetItemResponse) 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: QueryGetItemResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGetItemResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Item", 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.Item.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 *QueryGetItemByOnChainItemRequest) 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: QueryGetItemByOnChainItemRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGetItemByOnChainItemRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Chain", 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.Chain = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TokenID", 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.TokenID = 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 *QueryGetItemByOnChainItemResponse) 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: QueryGetItemByOnChainItemResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGetItemByOnChainItemResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Item", 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.Item.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 *QueryAllItemRequest) 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: QueryAllItemRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryAllItemRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pagination == nil {
				m.Pagination = &query.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 *QueryAllItemResponse) 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: QueryAllItemResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryAllItemResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Item", 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.Item = append(m.Item, Item{})
			if err := m.Item[len(m.Item)-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 *QueryGetOnChainItemRequest) 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: QueryGetOnChainItemRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGetOnChainItemRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Chain", 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.Chain = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TokenID", 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.TokenID = 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 *QueryGetOnChainItemResponse) 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: QueryGetOnChainItemResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGetOnChainItemResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Item", 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.Item.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 *QueryGetOnChainItemByOtherRequest) 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: QueryGetOnChainItemByOtherRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGetOnChainItemByOtherRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Chain", 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.Chain = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TokenID", 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.TokenID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetChain", 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.TargetChain = 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 *QueryGetOnChainItemByOtherResponse) 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: QueryGetOnChainItemByOtherResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGetOnChainItemByOtherResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Item", 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.Item.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 *QueryGetOnChainItemByItemForChainRequest) 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: QueryGetOnChainItemByItemForChainRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGetOnChainItemByItemForChainRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ItemIndex", 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.ItemIndex = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Chain", 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.Chain = 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 *QueryGetOnChainItemByItemForChainResponse) 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: QueryGetOnChainItemByItemForChainResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGetOnChainItemByItemForChainResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Item", 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.Item.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 *QueryAllOnChainItemRequest) 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: QueryAllOnChainItemRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryAllOnChainItemRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pagination == nil {
				m.Pagination = &query.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 *QueryAllOnChainItemResponse) 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: QueryAllOnChainItemResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryAllOnChainItemResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Item", 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.Item = append(m.Item, OnChainItem{})
			if err := m.Item[len(m.Item)-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 *QueryGetCollectionRequest) 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: QueryGetCollectionRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGetCollectionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", 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.Index = 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 *QueryGetCollectionResponse) 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: QueryGetCollectionResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGetCollectionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Collection", 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.Collection.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 *QueryGetCollectionByCollectionDataRequest) 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: QueryGetCollectionByCollectionDataRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGetCollectionByCollectionDataRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Chain", 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.Chain = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryGetCollectionDataResponse) 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: QueryGetCollectionDataResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGetCollectionDataResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", 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.Data.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 *QueryGetCollectionDataByCollectionForChainRequest) 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: QueryGetCollectionDataByCollectionForChainRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGetCollectionDataByCollectionForChainRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CollectionIndex", 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.CollectionIndex = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Chain", 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.Chain = 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 *QueryGetCollectionDataByCollectionForChainResponse) 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: QueryGetCollectionDataByCollectionForChainResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGetCollectionDataByCollectionForChainResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", 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.Data.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 *QueryGetNativeCollectionDataRequest) 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: QueryGetNativeCollectionDataRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGetNativeCollectionDataRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Collection", 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.Collection = 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 *QueryGetNativeCollectionDataResponse) 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: QueryGetNativeCollectionDataResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGetNativeCollectionDataResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", 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.Data.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 *QueryAllCollectionDataRequest) 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: QueryAllCollectionDataRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryAllCollectionDataRequest: 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 *QueryAllCollectionDataResponse) 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: QueryAllCollectionDataResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryAllCollectionDataResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", 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.Data = append(m.Data, CollectionData{})
			if err := m.Data[len(m.Data)-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 *QueryGetSeedRequest) 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: QueryGetSeedRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGetSeedRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Seed", 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.Seed = 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 *QueryGetSeedResponse) 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: QueryGetSeedResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGetSeedResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Seed", 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.Seed.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 *QueryAllSeedRequest) 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: QueryAllSeedRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryAllSeedRequest: 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 *QueryAllSeedResponse) 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: QueryAllSeedResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryAllSeedResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Seed", 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.Seed = append(m.Seed, Seed{})
			if err := m.Seed[len(m.Seed)-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 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")
)