query.pb.go

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

package types

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

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

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

// QueryHashesRequest is request type for the Query/Hashes RPC method.
// It involves retrieving all hashes that are maintained by the module.
type QueryHashesRequest struct {
	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryHashesRequest proto.InternalMessageInfo

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

// QueryHashesResponse is response type for the Query/Hashes RPC method.
type QueryHashesResponse struct {
	Hashes     []github_com_babylonchain_babylon_types.BTCHeaderHashBytes `protobuf:"bytes,1,rep,name=hashes,proto3,customtype=github.com/babylonchain/babylon/types.BTCHeaderHashBytes" json:"hashes,omitempty"`
	Pagination *query.PageResponse                                        `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryHashesResponse proto.InternalMessageInfo

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

// QueryContainsRequest is request type for the Query/Contains RPC method.
// It involves checking whether a hash is maintained by the module.
type QueryContainsRequest struct {
	Hash *github_com_babylonchain_babylon_types.BTCHeaderHashBytes `protobuf:"bytes,1,opt,name=hash,proto3,customtype=github.com/babylonchain/babylon/types.BTCHeaderHashBytes" json:"hash,omitempty"`
}

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

var xxx_messageInfo_QueryContainsRequest proto.InternalMessageInfo

// QueryContainsResponse is response type for the Query/Contains RPC method.
type QueryContainsResponse struct {
	Contains bool `protobuf:"varint,1,opt,name=contains,proto3" json:"contains,omitempty"`
}

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

var xxx_messageInfo_QueryContainsResponse proto.InternalMessageInfo

func (m *QueryContainsResponse) GetContains() bool {
	if m != nil {
		return m.Contains
	}
	return false
}

// QueryContainsRequest is request type for the temporary Query/ContainsBytes
// RPC method. It involves checking whether a hash is maintained by the module.
type QueryContainsBytesRequest struct {
	Hash []byte `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
}

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

var xxx_messageInfo_QueryContainsBytesRequest proto.InternalMessageInfo

func (m *QueryContainsBytesRequest) GetHash() []byte {
	if m != nil {
		return m.Hash
	}
	return nil
}

// QueryContainsResponse is response type for the temporary Query/ContainsBytes
// RPC method.
type QueryContainsBytesResponse struct {
	Contains bool `protobuf:"varint,1,opt,name=contains,proto3" json:"contains,omitempty"`
}

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

var xxx_messageInfo_QueryContainsBytesResponse proto.InternalMessageInfo

func (m *QueryContainsBytesResponse) GetContains() bool {
	if m != nil {
		return m.Contains
	}
	return false
}

// QueryMainChainRequest is request type for the Query/MainChain RPC method.
// It involves retrieving the canonical chain maintained by the module.
type QueryMainChainRequest struct {
	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryMainChainRequest proto.InternalMessageInfo

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

// QueryMainChainResponse is response type for the Query/MainChain RPC method.
type QueryMainChainResponse struct {
	Headers    []*BTCHeaderInfo    `protobuf:"bytes,1,rep,name=headers,proto3" json:"headers,omitempty"`
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryMainChainResponse proto.InternalMessageInfo

func (m *QueryMainChainResponse) GetHeaders() []*BTCHeaderInfo {
	if m != nil {
		return m.Headers
	}
	return nil
}

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

// QueryTipRequest is the request type for the Query/Tip RPC method.
type QueryTipRequest struct {
}

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

var xxx_messageInfo_QueryTipRequest proto.InternalMessageInfo

// QueryTipResponse is the response type for the Query/Tip RPC method.
type QueryTipResponse struct {
	Header *BTCHeaderInfo `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
}

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

var xxx_messageInfo_QueryTipResponse proto.InternalMessageInfo

func (m *QueryTipResponse) GetHeader() *BTCHeaderInfo {
	if m != nil {
		return m.Header
	}
	return nil
}

// QueryBaseHeaderRequest is the request type for the Query/BaseHeader RPC
// method.
type QueryBaseHeaderRequest struct {
}

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

var xxx_messageInfo_QueryBaseHeaderRequest proto.InternalMessageInfo

// QueryBaseHeaderResponse is the response type for the Query/BaseHeader RPC
// method.
type QueryBaseHeaderResponse struct {
	Header *BTCHeaderInfo `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
}

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

var xxx_messageInfo_QueryBaseHeaderResponse proto.InternalMessageInfo

func (m *QueryBaseHeaderResponse) GetHeader() *BTCHeaderInfo {
	if m != nil {
		return m.Header
	}
	return nil
}

func init() {
	proto.RegisterType((*QueryHashesRequest)(nil), "babylon.btclightclient.v1.QueryHashesRequest")
	proto.RegisterType((*QueryHashesResponse)(nil), "babylon.btclightclient.v1.QueryHashesResponse")
	proto.RegisterType((*QueryContainsRequest)(nil), "babylon.btclightclient.v1.QueryContainsRequest")
	proto.RegisterType((*QueryContainsResponse)(nil), "babylon.btclightclient.v1.QueryContainsResponse")
	proto.RegisterType((*QueryContainsBytesRequest)(nil), "babylon.btclightclient.v1.QueryContainsBytesRequest")
	proto.RegisterType((*QueryContainsBytesResponse)(nil), "babylon.btclightclient.v1.QueryContainsBytesResponse")
	proto.RegisterType((*QueryMainChainRequest)(nil), "babylon.btclightclient.v1.QueryMainChainRequest")
	proto.RegisterType((*QueryMainChainResponse)(nil), "babylon.btclightclient.v1.QueryMainChainResponse")
	proto.RegisterType((*QueryTipRequest)(nil), "babylon.btclightclient.v1.QueryTipRequest")
	proto.RegisterType((*QueryTipResponse)(nil), "babylon.btclightclient.v1.QueryTipResponse")
	proto.RegisterType((*QueryBaseHeaderRequest)(nil), "babylon.btclightclient.v1.QueryBaseHeaderRequest")
	proto.RegisterType((*QueryBaseHeaderResponse)(nil), "babylon.btclightclient.v1.QueryBaseHeaderResponse")
}

func init() {
	proto.RegisterFile("babylon/btclightclient/v1/query.proto", fileDescriptor_3961270631e52721)
}

var fileDescriptor_3961270631e52721 = []byte{
	// 694 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x96, 0xb1, 0x4f, 0x14, 0x4f,
	0x14, 0xc7, 0x19, 0xf8, 0xfd, 0x0e, 0x7c, 0x68, 0xd4, 0x11, 0x15, 0x36, 0x66, 0xc5, 0x45, 0xe0,
	0x04, 0xd9, 0xe1, 0x0e, 0x35, 0x14, 0x16, 0xe6, 0x48, 0x14, 0x0b, 0x13, 0xbc, 0x5c, 0xa5, 0x26,
	0x66, 0xf6, 0x1c, 0x77, 0x37, 0x81, 0x9d, 0x85, 0x19, 0x88, 0xd7, 0x5a, 0x58, 0x1b, 0xed, 0x2c,
	0x2c, 0x4c, 0x6c, 0xad, 0x6c, 0xfc, 0x0f, 0x2c, 0x49, 0x6c, 0x8c, 0x85, 0x31, 0xe0, 0x1f, 0x62,
	0x76, 0xe6, 0x1d, 0xc7, 0x1d, 0x72, 0xb7, 0x44, 0x1a, 0xc2, 0xee, 0xbc, 0xef, 0xfb, 0x7e, 0xe6,
	0x65, 0xbe, 0xb3, 0x07, 0x93, 0x01, 0x0f, 0x1a, 0xab, 0x32, 0x61, 0x81, 0xae, 0xaf, 0xc6, 0x61,
	0x94, 0xfd, 0x15, 0x89, 0x66, 0x5b, 0x25, 0xb6, 0xbe, 0x29, 0x36, 0x1a, 0x7e, 0xba, 0x21, 0xb5,
	0xa4, 0x63, 0x58, 0xe6, 0xb7, 0x97, 0xf9, 0x5b, 0x25, 0x67, 0x24, 0x94, 0xa1, 0x34, 0x55, 0x2c,
	0xfb, 0xcf, 0x0a, 0x9c, 0x4b, 0xa1, 0x94, 0xe1, 0xaa, 0x60, 0x3c, 0x8d, 0x19, 0x4f, 0x12, 0xa9,
	0xb9, 0x8e, 0x65, 0xa2, 0x70, 0x75, 0xa6, 0x2e, 0xd5, 0x9a, 0x54, 0x2c, 0xe0, 0x4a, 0x58, 0x1f,
	0xb6, 0x55, 0x0a, 0x84, 0xe6, 0x25, 0x96, 0xf2, 0x30, 0x4e, 0x4c, 0x31, 0xd6, 0xfa, 0x87, 0x13,
	0x76, 0xc0, 0x98, 0x7a, 0xef, 0x09, 0xd0, 0x87, 0x59, 0xc7, 0x65, 0xae, 0x22, 0xa1, 0xaa, 0x62,
	0x7d, 0x53, 0x28, 0x4d, 0xef, 0x02, 0xb4, 0x3a, 0x8f, 0x92, 0x71, 0x52, 0x1c, 0x2e, 0x4f, 0xf9,
	0x16, 0xc3, 0xcf, 0x30, 0x7c, 0xbb, 0x5d, 0xc4, 0xf0, 0x57, 0x78, 0x28, 0x50, 0x5b, 0xdd, 0xa7,
	0xf4, 0x3e, 0x13, 0x38, 0xd7, 0xd6, 0x5e, 0xa5, 0x32, 0x51, 0x82, 0xd6, 0xa0, 0x10, 0x99, 0x37,
	0xa3, 0x64, 0x7c, 0xa0, 0x78, 0xb2, 0x72, 0xfb, 0xc7, 0xcf, 0xcb, 0x8b, 0x61, 0xac, 0xa3, 0xcd,
	0xc0, 0xaf, 0xcb, 0x35, 0x86, 0x9b, 0xa8, 0x47, 0x3c, 0x4e, 0x9a, 0x0f, 0x4c, 0x37, 0x52, 0xa1,
	0xfc, 0x4a, 0x6d, 0x69, 0x59, 0xf0, 0x67, 0x62, 0x23, 0x6b, 0x59, 0x69, 0x68, 0xa1, 0xaa, 0xd8,
	0x8b, 0xde, 0x6b, 0xa3, 0xee, 0x37, 0xd4, 0xd3, 0x3d, 0xa9, 0x2d, 0x52, 0x1b, 0x76, 0x04, 0x23,
	0x86, 0x7a, 0x49, 0x26, 0x9a, 0xc7, 0xc9, 0xde, 0x58, 0x56, 0xe0, 0xbf, 0xcc, 0xca, 0x0c, 0xe4,
	0x5f, 0xa1, 0x4d, 0x27, 0x6f, 0x01, 0xce, 0x77, 0x38, 0xe1, 0x84, 0x1c, 0x18, 0xaa, 0xe3, 0x3b,
	0x63, 0x37, 0x54, 0xdd, 0x7b, 0xf6, 0x18, 0x8c, 0xb5, 0x89, 0x6c, 0x43, 0x64, 0xa4, 0xfb, 0x19,
	0xd1, 0x65, 0x11, 0x9c, 0xbf, 0x09, 0x72, 0x58, 0x3d, 0x45, 0xbe, 0x07, 0x3c, 0x4e, 0x96, 0xb2,
	0x8d, 0x1d, 0xf7, 0x09, 0xf9, 0x48, 0xe0, 0x42, 0xa7, 0x03, 0x72, 0x55, 0x60, 0x30, 0x32, 0x43,
	0xb3, 0xa7, 0x64, 0xb8, 0x5c, 0xf4, 0x0f, 0xcd, 0x55, 0x6b, 0xc2, 0xf7, 0x93, 0xe7, 0xb2, 0xda,
	0x14, 0x1e, 0xdf, 0x91, 0x38, 0x0b, 0xa7, 0x0d, 0x66, 0x2d, 0x4e, 0x71, 0x1b, 0x5e, 0x0d, 0xce,
	0xb4, 0x5e, 0x21, 0xf3, 0x1d, 0x28, 0x58, 0x6b, 0x1c, 0x49, 0x7e, 0x64, 0xd4, 0x79, 0xa3, 0x38,
	0x8f, 0x0a, 0x57, 0xc2, 0x2e, 0x37, 0xfd, 0x1e, 0xc3, 0xc5, 0x03, 0x2b, 0xc7, 0x65, 0x5b, 0xfe,
	0x32, 0x08, 0xff, 0x9b, 0xee, 0xf4, 0x0d, 0x81, 0x82, 0x8d, 0x2b, 0x9d, 0xeb, 0xd2, 0xe6, 0xe0,
	0xad, 0xe1, 0xf8, 0x79, 0xcb, 0x2d, 0xb5, 0x77, 0xed, 0xe5, 0xb7, 0xdf, 0x6f, 0xfb, 0x27, 0xe8,
	0x15, 0x76, 0xf8, 0xa5, 0x85, 0xd1, 0x7e, 0x47, 0x60, 0xa8, 0x79, 0x7a, 0x29, 0xeb, 0xe5, 0xd3,
	0x91, 0x5b, 0x67, 0x3e, 0xbf, 0x00, 0xd1, 0x66, 0x0d, 0xda, 0x24, 0x9d, 0xe8, 0x82, 0xd6, 0x0c,
	0x09, 0xfd, 0x44, 0xe0, 0x54, 0x5b, 0xb4, 0xe8, 0x8d, 0xbc, 0x86, 0xfb, 0xa3, 0xeb, 0xdc, 0x3c,
	0xa2, 0x0a, 0x59, 0xe7, 0x0d, 0xeb, 0x0c, 0x2d, 0xe6, 0x60, 0xb5, 0x78, 0xef, 0x09, 0x9c, 0xd8,
	0xcb, 0x1b, 0xed, 0x39, 0x9d, 0xce, 0xf0, 0x3b, 0xa5, 0x23, 0x28, 0x10, 0xf2, 0xba, 0x81, 0x9c,
	0xa2, 0x57, 0xbb, 0x40, 0xae, 0xf1, 0xd8, 0xde, 0x9e, 0xf4, 0x15, 0x81, 0x81, 0x5a, 0x9c, 0xd2,
	0x99, 0x5e, 0x46, 0xad, 0x38, 0x3a, 0xb3, 0xb9, 0x6a, 0x11, 0x67, 0xca, 0xe0, 0x8c, 0x53, 0xb7,
	0x0b, 0x8e, 0x8e, 0x53, 0xfa, 0x81, 0x00, 0xb4, 0xf2, 0x46, 0x7b, 0x6e, 0xfc, 0x40, 0x6a, 0x9d,
	0xf2, 0x51, 0x24, 0x48, 0x37, 0x67, 0xe8, 0xa6, 0xe9, 0x64, 0x17, 0xba, 0xec, 0xf2, 0xb2, 0xd9,
	0xad, 0xac, 0x7c, 0xdd, 0x71, 0xc9, 0xf6, 0x8e, 0x4b, 0x7e, 0xed, 0xb8, 0xe4, 0xf5, 0xae, 0xdb,
	0xb7, 0xbd, 0xeb, 0xf6, 0x7d, 0xdf, 0x75, 0xfb, 0x1e, 0xdd, 0xea, 0xf5, 0x79, 0x7a, 0xd1, 0xd9,
	0xd9, 0x7c, 0xaf, 0x82, 0x82, 0xf9, 0x71, 0xb0, 0xf0, 0x27, 0x00, 0x00, 0xff, 0xff, 0x88, 0x96,
	0xa9, 0x76, 0xf0, 0x08, 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 {
	// Hashes retrieves the hashes maintained by the module.
	Hashes(ctx context.Context, in *QueryHashesRequest, opts ...grpc.CallOption) (*QueryHashesResponse, error)
	// Contains checks whether a hash is maintained by the module.
	Contains(ctx context.Context, in *QueryContainsRequest, opts ...grpc.CallOption) (*QueryContainsResponse, error)
	// ContainsBytes is a temporary method that
	// checks whether a hash is maintained by the module.
	// See discussion at https://github.com/babylonchain/babylon/pull/132
	// for more details.
	ContainsBytes(ctx context.Context, in *QueryContainsBytesRequest, opts ...grpc.CallOption) (*QueryContainsBytesResponse, error)
	// MainChain returns the canonical chain
	MainChain(ctx context.Context, in *QueryMainChainRequest, opts ...grpc.CallOption) (*QueryMainChainResponse, error)
	// Tip return best header on canonical chain
	Tip(ctx context.Context, in *QueryTipRequest, opts ...grpc.CallOption) (*QueryTipResponse, error)
	// BaseHeader returns the base BTC header of the chain. This header is defined
	// on genesis.
	BaseHeader(ctx context.Context, in *QueryBaseHeaderRequest, opts ...grpc.CallOption) (*QueryBaseHeaderResponse, error)
}

type queryClient struct {
	cc grpc1.ClientConn
}

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

func (c *queryClient) Hashes(ctx context.Context, in *QueryHashesRequest, opts ...grpc.CallOption) (*QueryHashesResponse, error) {
	out := new(QueryHashesResponse)
	err := c.cc.Invoke(ctx, "/babylon.btclightclient.v1.Query/Hashes", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) Contains(ctx context.Context, in *QueryContainsRequest, opts ...grpc.CallOption) (*QueryContainsResponse, error) {
	out := new(QueryContainsResponse)
	err := c.cc.Invoke(ctx, "/babylon.btclightclient.v1.Query/Contains", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) ContainsBytes(ctx context.Context, in *QueryContainsBytesRequest, opts ...grpc.CallOption) (*QueryContainsBytesResponse, error) {
	out := new(QueryContainsBytesResponse)
	err := c.cc.Invoke(ctx, "/babylon.btclightclient.v1.Query/ContainsBytes", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) MainChain(ctx context.Context, in *QueryMainChainRequest, opts ...grpc.CallOption) (*QueryMainChainResponse, error) {
	out := new(QueryMainChainResponse)
	err := c.cc.Invoke(ctx, "/babylon.btclightclient.v1.Query/MainChain", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) Tip(ctx context.Context, in *QueryTipRequest, opts ...grpc.CallOption) (*QueryTipResponse, error) {
	out := new(QueryTipResponse)
	err := c.cc.Invoke(ctx, "/babylon.btclightclient.v1.Query/Tip", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) BaseHeader(ctx context.Context, in *QueryBaseHeaderRequest, opts ...grpc.CallOption) (*QueryBaseHeaderResponse, error) {
	out := new(QueryBaseHeaderResponse)
	err := c.cc.Invoke(ctx, "/babylon.btclightclient.v1.Query/BaseHeader", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// QueryServer is the server API for Query service.
type QueryServer interface {
	// Hashes retrieves the hashes maintained by the module.
	Hashes(context.Context, *QueryHashesRequest) (*QueryHashesResponse, error)
	// Contains checks whether a hash is maintained by the module.
	Contains(context.Context, *QueryContainsRequest) (*QueryContainsResponse, error)
	// ContainsBytes is a temporary method that
	// checks whether a hash is maintained by the module.
	// See discussion at https://github.com/babylonchain/babylon/pull/132
	// for more details.
	ContainsBytes(context.Context, *QueryContainsBytesRequest) (*QueryContainsBytesResponse, error)
	// MainChain returns the canonical chain
	MainChain(context.Context, *QueryMainChainRequest) (*QueryMainChainResponse, error)
	// Tip return best header on canonical chain
	Tip(context.Context, *QueryTipRequest) (*QueryTipResponse, error)
	// BaseHeader returns the base BTC header of the chain. This header is defined
	// on genesis.
	BaseHeader(context.Context, *QueryBaseHeaderRequest) (*QueryBaseHeaderResponse, error)
}

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

func (*UnimplementedQueryServer) Hashes(ctx context.Context, req *QueryHashesRequest) (*QueryHashesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Hashes not implemented")
}
func (*UnimplementedQueryServer) Contains(ctx context.Context, req *QueryContainsRequest) (*QueryContainsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Contains not implemented")
}
func (*UnimplementedQueryServer) ContainsBytes(ctx context.Context, req *QueryContainsBytesRequest) (*QueryContainsBytesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ContainsBytes not implemented")
}
func (*UnimplementedQueryServer) MainChain(ctx context.Context, req *QueryMainChainRequest) (*QueryMainChainResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MainChain not implemented")
}
func (*UnimplementedQueryServer) Tip(ctx context.Context, req *QueryTipRequest) (*QueryTipResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Tip not implemented")
}
func (*UnimplementedQueryServer) BaseHeader(ctx context.Context, req *QueryBaseHeaderRequest) (*QueryBaseHeaderResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BaseHeader not implemented")
}

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

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

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

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

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

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

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

var _Query_serviceDesc = grpc.ServiceDesc{
	ServiceName: "babylon.btclightclient.v1.Query",
	HandlerType: (*QueryServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Hashes",
			Handler:    _Query_Hashes_Handler,
		},
		{
			MethodName: "Contains",
			Handler:    _Query_Contains_Handler,
		},
		{
			MethodName: "ContainsBytes",
			Handler:    _Query_ContainsBytes_Handler,
		},
		{
			MethodName: "MainChain",
			Handler:    _Query_MainChain_Handler,
		},
		{
			MethodName: "Tip",
			Handler:    _Query_Tip_Handler,
		},
		{
			MethodName: "BaseHeader",
			Handler:    _Query_BaseHeader_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "babylon/btclightclient/v1/query.proto",
}

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

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

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

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

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

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

func (m *QueryContainsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Contains {
		i--
		if m.Contains {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *QueryContainsBytesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Contains {
		i--
		if m.Contains {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

func (m *QueryBaseHeaderResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Header != nil {
		{
			size, err := m.Header.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 *QueryHashesRequest) 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 *QueryHashesResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Hashes) > 0 {
		for _, e := range m.Hashes {
			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 *QueryContainsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Hash != nil {
		l = m.Hash.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryContainsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Contains {
		n += 2
	}
	return n
}

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

func (m *QueryContainsBytesResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Contains {
		n += 2
	}
	return n
}

func (m *QueryMainChainRequest) 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 *QueryMainChainResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Headers) > 0 {
		for _, e := range m.Headers {
			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 *QueryTipRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

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

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

func (m *QueryBaseHeaderResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Header != nil {
		l = m.Header.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 *QueryHashesRequest) 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: QueryHashesRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryHashesRequest: 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 *QueryHashesResponse) 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: QueryHashesResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryHashesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hashes", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_babylonchain_babylon_types.BTCHeaderHashBytes
			m.Hashes = append(m.Hashes, v)
			if err := m.Hashes[len(m.Hashes)-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 *QueryContainsRequest) 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: QueryContainsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryContainsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_babylonchain_babylon_types.BTCHeaderHashBytes
			m.Hash = &v
			if err := m.Hash.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 *QueryContainsResponse) 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: QueryContainsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryContainsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Contains", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Contains = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryMainChainRequest) 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: QueryMainChainRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryMainChainRequest: 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 *QueryMainChainResponse) 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: QueryMainChainResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryMainChainResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Headers", 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.Headers = append(m.Headers, &BTCHeaderInfo{})
			if err := m.Headers[len(m.Headers)-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 *QueryTipRequest) 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: QueryTipRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryTipRequest: 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 *QueryTipResponse) 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: QueryTipResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryTipResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Header", 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.Header == nil {
				m.Header = &BTCHeaderInfo{}
			}
			if err := m.Header.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 *QueryBaseHeaderRequest) 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: QueryBaseHeaderRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryBaseHeaderRequest: 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 *QueryBaseHeaderResponse) 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: QueryBaseHeaderResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryBaseHeaderResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Header", 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.Header == nil {
				m.Header = &BTCHeaderInfo{}
			}
			if err := m.Header.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")
)