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

package pb

import (
	context "context"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_meshplus_bitxhub_kit_types "github.com/meshplus/bitxhub-kit/types"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	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

type GetBlockRequest_Type int32

const (
	GetBlockRequest_HEIGHT GetBlockRequest_Type = 0
	GetBlockRequest_HASH   GetBlockRequest_Type = 1
)

var GetBlockRequest_Type_name = map[int32]string{
	0: "HEIGHT",
	1: "HASH",
}

var GetBlockRequest_Type_value = map[string]int32{
	"HEIGHT": 0,
	"HASH":   1,
}

func (x GetBlockRequest_Type) String() string {
	return proto.EnumName(GetBlockRequest_Type_name, int32(x))
}

func (GetBlockRequest_Type) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f209535e190f2bed, []int{3, 0}
}

type Request_Type int32

const (
	Request_CHAIN_STATUS Request_Type = 0
	Request_NETWORK      Request_Type = 1
	Request_VALIDATORS   Request_Type = 2
)

var Request_Type_name = map[int32]string{
	0: "CHAIN_STATUS",
	1: "NETWORK",
	2: "VALIDATORS",
}

var Request_Type_value = map[string]int32{
	"CHAIN_STATUS": 0,
	"NETWORK":      1,
	"VALIDATORS":   2,
}

func (x Request_Type) String() string {
	return proto.EnumName(Request_Type_name, int32(x))
}

func (Request_Type) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f209535e190f2bed, []int{4, 0}
}

type SubscriptionRequest_Type int32

const (
	SubscriptionRequest_BLOCK                       SubscriptionRequest_Type = 0
	SubscriptionRequest_EVENT                       SubscriptionRequest_Type = 1
	SubscriptionRequest_INTERCHAIN_TX               SubscriptionRequest_Type = 2
	SubscriptionRequest_BLOCK_HEADER                SubscriptionRequest_Type = 3
	SubscriptionRequest_INTERCHAIN_TX_WRAPPER       SubscriptionRequest_Type = 4
	SubscriptionRequest_UNION_INTERCHAIN_TX_WRAPPER SubscriptionRequest_Type = 5
)

var SubscriptionRequest_Type_name = map[int32]string{
	0: "BLOCK",
	1: "EVENT",
	2: "INTERCHAIN_TX",
	3: "BLOCK_HEADER",
	4: "INTERCHAIN_TX_WRAPPER",
	5: "UNION_INTERCHAIN_TX_WRAPPER",
}

var SubscriptionRequest_Type_value = map[string]int32{
	"BLOCK":                       0,
	"EVENT":                       1,
	"INTERCHAIN_TX":               2,
	"BLOCK_HEADER":                3,
	"INTERCHAIN_TX_WRAPPER":       4,
	"UNION_INTERCHAIN_TX_WRAPPER": 5,
}

func (x SubscriptionRequest_Type) String() string {
	return proto.EnumName(SubscriptionRequest_Type_name, int32(x))
}

func (SubscriptionRequest_Type) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f209535e190f2bed, []int{12, 0}
}

type GetMultiSignsRequest_Type int32

const (
	GetMultiSignsRequest_ASSET_EXCHANGE GetMultiSignsRequest_Type = 0
	GetMultiSignsRequest_IBTP           GetMultiSignsRequest_Type = 1
	GetMultiSignsRequest_BLOCK_HEADER   GetMultiSignsRequest_Type = 2
)

var GetMultiSignsRequest_Type_name = map[int32]string{
	0: "ASSET_EXCHANGE",
	1: "IBTP",
	2: "BLOCK_HEADER",
}

var GetMultiSignsRequest_Type_value = map[string]int32{
	"ASSET_EXCHANGE": 0,
	"IBTP":           1,
	"BLOCK_HEADER":   2,
}

func (x GetMultiSignsRequest_Type) String() string {
	return proto.EnumName(GetMultiSignsRequest_Type_name, int32(x))
}

func (GetMultiSignsRequest_Type) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f209535e190f2bed, []int{13, 0}
}

type CheckSidecarResponse_Status int32

const (
	CheckSidecarResponse_ERROR_MASTER CheckSidecarResponse_Status = 0
	CheckSidecarResponse_HAS_MASTER   CheckSidecarResponse_Status = 1
	CheckSidecarResponse_NO_MASTER    CheckSidecarResponse_Status = 2
)

var CheckSidecarResponse_Status_name = map[int32]string{
	0: "ERROR_MASTER",
	1: "HAS_MASTER",
	2: "NO_MASTER",
}

var CheckSidecarResponse_Status_value = map[string]int32{
	"ERROR_MASTER": 0,
	"HAS_MASTER":   1,
	"NO_MASTER":    2,
}

func (x CheckSidecarResponse_Status) String() string {
	return proto.EnumName(CheckSidecarResponse_Status_name, int32(x))
}

func (CheckSidecarResponse_Status) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f209535e190f2bed, []int{21, 0}
}

type HeartBeatRespones_Status int32

const (
	HeartBeatRespones_ALIVE HeartBeatRespones_Status = 0
	HeartBeatRespones_DEAD  HeartBeatRespones_Status = 1
)

var HeartBeatRespones_Status_name = map[int32]string{
	0: "ALIVE",
	1: "DEAD",
}

var HeartBeatRespones_Status_value = map[string]int32{
	"ALIVE": 0,
	"DEAD":  1,
}

func (x HeartBeatRespones_Status) String() string {
	return proto.EnumName(HeartBeatRespones_Status_name, int32(x))
}

func (HeartBeatRespones_Status) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f209535e190f2bed, []int{22, 0}
}

type GetBlockHeaderRequest struct {
	Begin uint64 `protobuf:"varint,1,opt,name=begin,proto3" json:"begin,omitempty"`
	End   uint64 `protobuf:"varint,2,opt,name=end,proto3" json:"end,omitempty"`
}

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

var xxx_messageInfo_GetBlockHeaderRequest proto.InternalMessageInfo

func (m *GetBlockHeaderRequest) GetBegin() uint64 {
	if m != nil {
		return m.Begin
	}
	return 0
}

func (m *GetBlockHeaderRequest) GetEnd() uint64 {
	if m != nil {
		return m.End
	}
	return 0
}

type GetInterchainTxWrappersRequest struct {
	Begin uint64 `protobuf:"varint,1,opt,name=begin,proto3" json:"begin,omitempty"`
	End   uint64 `protobuf:"varint,2,opt,name=end,proto3" json:"end,omitempty"`
	Pid   string `protobuf:"bytes,3,opt,name=pid,proto3" json:"pid,omitempty"`
}

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

var xxx_messageInfo_GetInterchainTxWrappersRequest proto.InternalMessageInfo

func (m *GetInterchainTxWrappersRequest) GetBegin() uint64 {
	if m != nil {
		return m.Begin
	}
	return 0
}

func (m *GetInterchainTxWrappersRequest) GetEnd() uint64 {
	if m != nil {
		return m.End
	}
	return 0
}

func (m *GetInterchainTxWrappersRequest) GetPid() string {
	if m != nil {
		return m.Pid
	}
	return ""
}

type TransactionHashMsg struct {
	TxHash string `protobuf:"bytes,1,opt,name=tx_hash,json=txHash,proto3" json:"tx_hash,omitempty"`
}

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

var xxx_messageInfo_TransactionHashMsg proto.InternalMessageInfo

func (m *TransactionHashMsg) GetTxHash() string {
	if m != nil {
		return m.TxHash
	}
	return ""
}

type GetBlockRequest struct {
	Type  GetBlockRequest_Type `protobuf:"varint,1,opt,name=type,proto3,enum=pb.GetBlockRequest_Type" json:"type,omitempty"`
	Value string               `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_GetBlockRequest proto.InternalMessageInfo

func (m *GetBlockRequest) GetType() GetBlockRequest_Type {
	if m != nil {
		return m.Type
	}
	return GetBlockRequest_HEIGHT
}

func (m *GetBlockRequest) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type Request struct {
	Type Request_Type `protobuf:"varint,1,opt,name=type,proto3,enum=pb.Request_Type" json:"type,omitempty"`
}

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

var xxx_messageInfo_Request proto.InternalMessageInfo

func (m *Request) GetType() Request_Type {
	if m != nil {
		return m.Type
	}
	return Request_CHAIN_STATUS
}

type Response struct {
	Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
}

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

var xxx_messageInfo_Response proto.InternalMessageInfo

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

type SignResponse struct {
	Sign map[string][]byte `protobuf:"bytes,1,rep,name=sign,proto3" json:"sign,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

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

var xxx_messageInfo_SignResponse proto.InternalMessageInfo

func (m *SignResponse) GetSign() map[string][]byte {
	if m != nil {
		return m.Sign
	}
	return nil
}

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

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

var xxx_messageInfo_Address proto.InternalMessageInfo

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

type GetBlocksRequest struct {
	Start uint64 `protobuf:"varint,1,opt,name=start,proto3" json:"start,omitempty"`
	End   uint64 `protobuf:"varint,2,opt,name=end,proto3" json:"end,omitempty"`
}

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

var xxx_messageInfo_GetBlocksRequest proto.InternalMessageInfo

func (m *GetBlocksRequest) GetStart() uint64 {
	if m != nil {
		return m.Start
	}
	return 0
}

func (m *GetBlocksRequest) GetEnd() uint64 {
	if m != nil {
		return m.End
	}
	return 0
}

type GetBlocksResponse struct {
	Blocks []*Block `protobuf:"bytes,1,rep,name=blocks,proto3" json:"blocks,omitempty"`
}

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

var xxx_messageInfo_GetBlocksResponse proto.InternalMessageInfo

func (m *GetBlocksResponse) GetBlocks() []*Block {
	if m != nil {
		return m.Blocks
	}
	return nil
}

type GetBlockHeadersRequest struct {
	Start uint64 `protobuf:"varint,1,opt,name=start,proto3" json:"start,omitempty"`
	End   uint64 `protobuf:"varint,2,opt,name=end,proto3" json:"end,omitempty"`
}

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

var xxx_messageInfo_GetBlockHeadersRequest proto.InternalMessageInfo

func (m *GetBlockHeadersRequest) GetStart() uint64 {
	if m != nil {
		return m.Start
	}
	return 0
}

func (m *GetBlockHeadersRequest) GetEnd() uint64 {
	if m != nil {
		return m.End
	}
	return 0
}

type GetBlockHeadersResponse struct {
	BlockHeaders []*BlockHeader `protobuf:"bytes,1,rep,name=blockHeaders,proto3" json:"blockHeaders,omitempty"`
}

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

var xxx_messageInfo_GetBlockHeadersResponse proto.InternalMessageInfo

func (m *GetBlockHeadersResponse) GetBlockHeaders() []*BlockHeader {
	if m != nil {
		return m.BlockHeaders
	}
	return nil
}

type SubscriptionRequest struct {
	Type  SubscriptionRequest_Type `protobuf:"varint,1,opt,name=type,proto3,enum=pb.SubscriptionRequest_Type" json:"type,omitempty"`
	Extra []byte                   `protobuf:"bytes,2,opt,name=extra,proto3" json:"extra,omitempty"`
}

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

var xxx_messageInfo_SubscriptionRequest proto.InternalMessageInfo

func (m *SubscriptionRequest) GetType() SubscriptionRequest_Type {
	if m != nil {
		return m.Type
	}
	return SubscriptionRequest_BLOCK
}

func (m *SubscriptionRequest) GetExtra() []byte {
	if m != nil {
		return m.Extra
	}
	return nil
}

type GetMultiSignsRequest struct {
	Type    GetMultiSignsRequest_Type `protobuf:"varint,1,opt,name=type,proto3,enum=pb.GetMultiSignsRequest_Type" json:"type,omitempty"`
	Content string                    `protobuf:"bytes,2,opt,name=content,proto3" json:"content,omitempty"`
}

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

var xxx_messageInfo_GetMultiSignsRequest proto.InternalMessageInfo

func (m *GetMultiSignsRequest) GetType() GetMultiSignsRequest_Type {
	if m != nil {
		return m.Type
	}
	return GetMultiSignsRequest_ASSET_EXCHANGE
}

func (m *GetMultiSignsRequest) GetContent() string {
	if m != nil {
		return m.Content
	}
	return ""
}

type GetTransactionResponse struct {
	Tx     *BxhTransaction  `protobuf:"bytes,1,opt,name=tx,proto3" json:"tx,omitempty"`
	TxMeta *TransactionMeta `protobuf:"bytes,2,opt,name=tx_meta,json=txMeta,proto3" json:"tx_meta,omitempty"`
}

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

var xxx_messageInfo_GetTransactionResponse proto.InternalMessageInfo

func (m *GetTransactionResponse) GetTx() *BxhTransaction {
	if m != nil {
		return m.Tx
	}
	return nil
}

func (m *GetTransactionResponse) GetTxMeta() *TransactionMeta {
	if m != nil {
		return m.TxMeta
	}
	return nil
}

type VerifiedTx struct {
	Tx    *BxhTransaction `protobuf:"bytes,1,opt,name=tx,proto3" json:"tx,omitempty"`
	Valid bool            `protobuf:"varint,2,opt,name=valid,proto3" json:"valid,omitempty"`
}

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

var xxx_messageInfo_VerifiedTx proto.InternalMessageInfo

func (m *VerifiedTx) GetTx() *BxhTransaction {
	if m != nil {
		return m.Tx
	}
	return nil
}

func (m *VerifiedTx) GetValid() bool {
	if m != nil {
		return m.Valid
	}
	return false
}

type InterchainTxWrapper struct {
	L2Roots      []github_com_meshplus_bitxhub_kit_types.Hash `protobuf:"bytes,1,rep,name=l2Roots,proto3,customtype=github.com/meshplus/bitxhub-kit/types.Hash" json:"l2Roots,omitempty"`
	Transactions []*VerifiedTx                                `protobuf:"bytes,2,rep,name=transactions,proto3" json:"transactions,omitempty"`
	Height       uint64                                       `protobuf:"varint,3,opt,name=height,proto3" json:"height,omitempty"`
}

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

var xxx_messageInfo_InterchainTxWrapper proto.InternalMessageInfo

func (m *InterchainTxWrapper) GetTransactions() []*VerifiedTx {
	if m != nil {
		return m.Transactions
	}
	return nil
}

func (m *InterchainTxWrapper) GetHeight() uint64 {
	if m != nil {
		return m.Height
	}
	return 0
}

type InterchainTxWrappers struct {
	InterchainTxWrappers []*InterchainTxWrapper `protobuf:"bytes,1,rep,name=interchainTxWrappers,proto3" json:"interchainTxWrappers,omitempty"`
}

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

var xxx_messageInfo_InterchainTxWrappers proto.InternalMessageInfo

func (m *InterchainTxWrappers) GetInterchainTxWrappers() []*InterchainTxWrapper {
	if m != nil {
		return m.InterchainTxWrappers
	}
	return nil
}

type GetTPSRequest struct {
	Begin uint64 `protobuf:"varint,1,opt,name=begin,proto3" json:"begin,omitempty"`
	End   uint64 `protobuf:"varint,2,opt,name=end,proto3" json:"end,omitempty"`
}

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

var xxx_messageInfo_GetTPSRequest proto.InternalMessageInfo

func (m *GetTPSRequest) GetBegin() uint64 {
	if m != nil {
		return m.Begin
	}
	return 0
}

func (m *GetTPSRequest) GetEnd() uint64 {
	if m != nil {
		return m.End
	}
	return 0
}

type DelVPNodeRequest struct {
	Pid string `protobuf:"bytes,1,opt,name=pid,proto3" json:"pid,omitempty"`
}

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

var xxx_messageInfo_DelVPNodeRequest proto.InternalMessageInfo

func (m *DelVPNodeRequest) GetPid() string {
	if m != nil {
		return m.Pid
	}
	return ""
}

type SidecarInfo struct {
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	Index   string `protobuf:"bytes,2,opt,name=index,proto3" json:"index,omitempty"`
	Timeout int64  `protobuf:"varint,3,opt,name=timeout,proto3" json:"timeout,omitempty"`
}

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

var xxx_messageInfo_SidecarInfo proto.InternalMessageInfo

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

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

func (m *SidecarInfo) GetTimeout() int64 {
	if m != nil {
		return m.Timeout
	}
	return 0
}

type CheckSidecarResponse struct {
	Status  CheckSidecarResponse_Status `protobuf:"varint,1,opt,name=status,proto3,enum=pb.CheckSidecarResponse_Status" json:"status,omitempty"`
	Address string                      `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
}

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

var xxx_messageInfo_CheckSidecarResponse proto.InternalMessageInfo

func (m *CheckSidecarResponse) GetStatus() CheckSidecarResponse_Status {
	if m != nil {
		return m.Status
	}
	return CheckSidecarResponse_ERROR_MASTER
}

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

type HeartBeatRespones struct {
	Status HeartBeatRespones_Status `protobuf:"varint,1,opt,name=status,proto3,enum=pb.HeartBeatRespones_Status" json:"status,omitempty"`
}

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

var xxx_messageInfo_HeartBeatRespones proto.InternalMessageInfo

func (m *HeartBeatRespones) GetStatus() HeartBeatRespones_Status {
	if m != nil {
		return m.Status
	}
	return HeartBeatRespones_ALIVE
}

func init() {
	proto.RegisterEnum("pb.GetBlockRequest_Type", GetBlockRequest_Type_name, GetBlockRequest_Type_value)
	proto.RegisterEnum("pb.Request_Type", Request_Type_name, Request_Type_value)
	proto.RegisterEnum("pb.SubscriptionRequest_Type", SubscriptionRequest_Type_name, SubscriptionRequest_Type_value)
	proto.RegisterEnum("pb.GetMultiSignsRequest_Type", GetMultiSignsRequest_Type_name, GetMultiSignsRequest_Type_value)
	proto.RegisterEnum("pb.CheckSidecarResponse_Status", CheckSidecarResponse_Status_name, CheckSidecarResponse_Status_value)
	proto.RegisterEnum("pb.HeartBeatRespones_Status", HeartBeatRespones_Status_name, HeartBeatRespones_Status_value)
	proto.RegisterType((*GetBlockHeaderRequest)(nil), "pb.GetBlockHeaderRequest")
	proto.RegisterType((*GetInterchainTxWrappersRequest)(nil), "pb.GetInterchainTxWrappersRequest")
	proto.RegisterType((*TransactionHashMsg)(nil), "pb.TransactionHashMsg")
	proto.RegisterType((*GetBlockRequest)(nil), "pb.GetBlockRequest")
	proto.RegisterType((*Request)(nil), "pb.Request")
	proto.RegisterType((*Response)(nil), "pb.Response")
	proto.RegisterType((*SignResponse)(nil), "pb.SignResponse")
	proto.RegisterMapType((map[string][]byte)(nil), "pb.SignResponse.SignEntry")
	proto.RegisterType((*Address)(nil), "pb.Address")
	proto.RegisterType((*GetBlocksRequest)(nil), "pb.GetBlocksRequest")
	proto.RegisterType((*GetBlocksResponse)(nil), "pb.GetBlocksResponse")
	proto.RegisterType((*GetBlockHeadersRequest)(nil), "pb.GetBlockHeadersRequest")
	proto.RegisterType((*GetBlockHeadersResponse)(nil), "pb.GetBlockHeadersResponse")
	proto.RegisterType((*SubscriptionRequest)(nil), "pb.SubscriptionRequest")
	proto.RegisterType((*GetMultiSignsRequest)(nil), "pb.GetMultiSignsRequest")
	proto.RegisterType((*GetTransactionResponse)(nil), "pb.GetTransactionResponse")
	proto.RegisterType((*VerifiedTx)(nil), "pb.VerifiedTx")
	proto.RegisterType((*InterchainTxWrapper)(nil), "pb.InterchainTxWrapper")
	proto.RegisterType((*InterchainTxWrappers)(nil), "pb.InterchainTxWrappers")
	proto.RegisterType((*GetTPSRequest)(nil), "pb.GetTPSRequest")
	proto.RegisterType((*DelVPNodeRequest)(nil), "pb.DelVPNodeRequest")
	proto.RegisterType((*SidecarInfo)(nil), "pb.SidecarInfo")
	proto.RegisterType((*CheckSidecarResponse)(nil), "pb.CheckSidecarResponse")
	proto.RegisterType((*HeartBeatRespones)(nil), "pb.HeartBeatRespones")
}

func init() { proto.RegisterFile("broker.proto", fileDescriptor_f209535e190f2bed) }

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

// ChainBrokerClient is the client API for ChainBroker service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ChainBrokerClient interface {
	Subscribe(ctx context.Context, in *SubscriptionRequest, opts ...grpc.CallOption) (ChainBroker_SubscribeClient, error)
	GetBlockHeader(ctx context.Context, in *GetBlockHeaderRequest, opts ...grpc.CallOption) (ChainBroker_GetBlockHeaderClient, error)
	GetInterchainTxWrappers(ctx context.Context, in *GetInterchainTxWrappersRequest, opts ...grpc.CallOption) (ChainBroker_GetInterchainTxWrappersClient, error)
	SendTransaction(ctx context.Context, in *BxhTransaction, opts ...grpc.CallOption) (*TransactionHashMsg, error)
	SendView(ctx context.Context, in *BxhTransaction, opts ...grpc.CallOption) (*Receipt, error)
	GetTransaction(ctx context.Context, in *TransactionHashMsg, opts ...grpc.CallOption) (*GetTransactionResponse, error)
	GetReceipt(ctx context.Context, in *TransactionHashMsg, opts ...grpc.CallOption) (*Receipt, error)
	GetBlock(ctx context.Context, in *GetBlockRequest, opts ...grpc.CallOption) (*Block, error)
	GetBlocks(ctx context.Context, in *GetBlocksRequest, opts ...grpc.CallOption) (*GetBlocksResponse, error)
	GetBlockHeaders(ctx context.Context, in *GetBlockHeadersRequest, opts ...grpc.CallOption) (*GetBlockHeadersResponse, error)
	GetChainMeta(ctx context.Context, in *Request, opts ...grpc.CallOption) (*ChainMeta, error)
	GetInfo(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error)
	GetAccountBalance(ctx context.Context, in *Address, opts ...grpc.CallOption) (*Response, error)
	GetMultiSigns(ctx context.Context, in *GetMultiSignsRequest, opts ...grpc.CallOption) (*SignResponse, error)
	GetTPS(ctx context.Context, in *GetTPSRequest, opts ...grpc.CallOption) (*Response, error)
	GetPendingNonceByAccount(ctx context.Context, in *Address, opts ...grpc.CallOption) (*Response, error)
	DelVPNode(ctx context.Context, in *DelVPNodeRequest, opts ...grpc.CallOption) (*Response, error)
	CheckMasterSidecar(ctx context.Context, in *Address, opts ...grpc.CallOption) (*Response, error)
	SetMasterSidecar(ctx context.Context, in *SidecarInfo, opts ...grpc.CallOption) (*Response, error)
	HeartBeat(ctx context.Context, in *SidecarInfo, opts ...grpc.CallOption) (*Response, error)
}

type chainBrokerClient struct {
	cc *grpc.ClientConn
}

func NewChainBrokerClient(cc *grpc.ClientConn) ChainBrokerClient {
	return &chainBrokerClient{cc}
}

func (c *chainBrokerClient) Subscribe(ctx context.Context, in *SubscriptionRequest, opts ...grpc.CallOption) (ChainBroker_SubscribeClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ChainBroker_serviceDesc.Streams[0], "/pb.ChainBroker/Subscribe", opts...)
	if err != nil {
		return nil, err
	}
	x := &chainBrokerSubscribeClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ChainBroker_SubscribeClient interface {
	Recv() (*Response, error)
	grpc.ClientStream
}

type chainBrokerSubscribeClient struct {
	grpc.ClientStream
}

func (x *chainBrokerSubscribeClient) Recv() (*Response, error) {
	m := new(Response)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *chainBrokerClient) GetBlockHeader(ctx context.Context, in *GetBlockHeaderRequest, opts ...grpc.CallOption) (ChainBroker_GetBlockHeaderClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ChainBroker_serviceDesc.Streams[1], "/pb.ChainBroker/GetBlockHeader", opts...)
	if err != nil {
		return nil, err
	}
	x := &chainBrokerGetBlockHeaderClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ChainBroker_GetBlockHeaderClient interface {
	Recv() (*BlockHeader, error)
	grpc.ClientStream
}

type chainBrokerGetBlockHeaderClient struct {
	grpc.ClientStream
}

func (x *chainBrokerGetBlockHeaderClient) Recv() (*BlockHeader, error) {
	m := new(BlockHeader)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *chainBrokerClient) GetInterchainTxWrappers(ctx context.Context, in *GetInterchainTxWrappersRequest, opts ...grpc.CallOption) (ChainBroker_GetInterchainTxWrappersClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ChainBroker_serviceDesc.Streams[2], "/pb.ChainBroker/GetInterchainTxWrappers", opts...)
	if err != nil {
		return nil, err
	}
	x := &chainBrokerGetInterchainTxWrappersClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ChainBroker_GetInterchainTxWrappersClient interface {
	Recv() (*InterchainTxWrappers, error)
	grpc.ClientStream
}

type chainBrokerGetInterchainTxWrappersClient struct {
	grpc.ClientStream
}

func (x *chainBrokerGetInterchainTxWrappersClient) Recv() (*InterchainTxWrappers, error) {
	m := new(InterchainTxWrappers)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *chainBrokerClient) SendTransaction(ctx context.Context, in *BxhTransaction, opts ...grpc.CallOption) (*TransactionHashMsg, error) {
	out := new(TransactionHashMsg)
	err := c.cc.Invoke(ctx, "/pb.ChainBroker/SendTransaction", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *chainBrokerClient) SendView(ctx context.Context, in *BxhTransaction, opts ...grpc.CallOption) (*Receipt, error) {
	out := new(Receipt)
	err := c.cc.Invoke(ctx, "/pb.ChainBroker/SendView", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *chainBrokerClient) GetTransaction(ctx context.Context, in *TransactionHashMsg, opts ...grpc.CallOption) (*GetTransactionResponse, error) {
	out := new(GetTransactionResponse)
	err := c.cc.Invoke(ctx, "/pb.ChainBroker/GetTransaction", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *chainBrokerClient) GetReceipt(ctx context.Context, in *TransactionHashMsg, opts ...grpc.CallOption) (*Receipt, error) {
	out := new(Receipt)
	err := c.cc.Invoke(ctx, "/pb.ChainBroker/GetReceipt", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *chainBrokerClient) GetBlock(ctx context.Context, in *GetBlockRequest, opts ...grpc.CallOption) (*Block, error) {
	out := new(Block)
	err := c.cc.Invoke(ctx, "/pb.ChainBroker/GetBlock", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *chainBrokerClient) GetBlocks(ctx context.Context, in *GetBlocksRequest, opts ...grpc.CallOption) (*GetBlocksResponse, error) {
	out := new(GetBlocksResponse)
	err := c.cc.Invoke(ctx, "/pb.ChainBroker/GetBlocks", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *chainBrokerClient) GetBlockHeaders(ctx context.Context, in *GetBlockHeadersRequest, opts ...grpc.CallOption) (*GetBlockHeadersResponse, error) {
	out := new(GetBlockHeadersResponse)
	err := c.cc.Invoke(ctx, "/pb.ChainBroker/GetBlockHeaders", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *chainBrokerClient) GetChainMeta(ctx context.Context, in *Request, opts ...grpc.CallOption) (*ChainMeta, error) {
	out := new(ChainMeta)
	err := c.cc.Invoke(ctx, "/pb.ChainBroker/GetChainMeta", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *chainBrokerClient) GetInfo(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error) {
	out := new(Response)
	err := c.cc.Invoke(ctx, "/pb.ChainBroker/GetInfo", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *chainBrokerClient) GetAccountBalance(ctx context.Context, in *Address, opts ...grpc.CallOption) (*Response, error) {
	out := new(Response)
	err := c.cc.Invoke(ctx, "/pb.ChainBroker/GetAccountBalance", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *chainBrokerClient) GetMultiSigns(ctx context.Context, in *GetMultiSignsRequest, opts ...grpc.CallOption) (*SignResponse, error) {
	out := new(SignResponse)
	err := c.cc.Invoke(ctx, "/pb.ChainBroker/GetMultiSigns", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *chainBrokerClient) GetTPS(ctx context.Context, in *GetTPSRequest, opts ...grpc.CallOption) (*Response, error) {
	out := new(Response)
	err := c.cc.Invoke(ctx, "/pb.ChainBroker/GetTPS", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *chainBrokerClient) GetPendingNonceByAccount(ctx context.Context, in *Address, opts ...grpc.CallOption) (*Response, error) {
	out := new(Response)
	err := c.cc.Invoke(ctx, "/pb.ChainBroker/GetPendingNonceByAccount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *chainBrokerClient) DelVPNode(ctx context.Context, in *DelVPNodeRequest, opts ...grpc.CallOption) (*Response, error) {
	out := new(Response)
	err := c.cc.Invoke(ctx, "/pb.ChainBroker/DelVPNode", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *chainBrokerClient) CheckMasterSidecar(ctx context.Context, in *Address, opts ...grpc.CallOption) (*Response, error) {
	out := new(Response)
	err := c.cc.Invoke(ctx, "/pb.ChainBroker/CheckMasterSidecar", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *chainBrokerClient) SetMasterSidecar(ctx context.Context, in *SidecarInfo, opts ...grpc.CallOption) (*Response, error) {
	out := new(Response)
	err := c.cc.Invoke(ctx, "/pb.ChainBroker/SetMasterSidecar", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *chainBrokerClient) HeartBeat(ctx context.Context, in *SidecarInfo, opts ...grpc.CallOption) (*Response, error) {
	out := new(Response)
	err := c.cc.Invoke(ctx, "/pb.ChainBroker/HeartBeat", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ChainBrokerServer is the server API for ChainBroker service.
type ChainBrokerServer interface {
	Subscribe(*SubscriptionRequest, ChainBroker_SubscribeServer) error
	GetBlockHeader(*GetBlockHeaderRequest, ChainBroker_GetBlockHeaderServer) error
	GetInterchainTxWrappers(*GetInterchainTxWrappersRequest, ChainBroker_GetInterchainTxWrappersServer) error
	SendTransaction(context.Context, *BxhTransaction) (*TransactionHashMsg, error)
	SendView(context.Context, *BxhTransaction) (*Receipt, error)
	GetTransaction(context.Context, *TransactionHashMsg) (*GetTransactionResponse, error)
	GetReceipt(context.Context, *TransactionHashMsg) (*Receipt, error)
	GetBlock(context.Context, *GetBlockRequest) (*Block, error)
	GetBlocks(context.Context, *GetBlocksRequest) (*GetBlocksResponse, error)
	GetBlockHeaders(context.Context, *GetBlockHeadersRequest) (*GetBlockHeadersResponse, error)
	GetChainMeta(context.Context, *Request) (*ChainMeta, error)
	GetInfo(context.Context, *Request) (*Response, error)
	GetAccountBalance(context.Context, *Address) (*Response, error)
	GetMultiSigns(context.Context, *GetMultiSignsRequest) (*SignResponse, error)
	GetTPS(context.Context, *GetTPSRequest) (*Response, error)
	GetPendingNonceByAccount(context.Context, *Address) (*Response, error)
	DelVPNode(context.Context, *DelVPNodeRequest) (*Response, error)
	CheckMasterSidecar(context.Context, *Address) (*Response, error)
	SetMasterSidecar(context.Context, *SidecarInfo) (*Response, error)
	HeartBeat(context.Context, *SidecarInfo) (*Response, error)
}

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

func (*UnimplementedChainBrokerServer) Subscribe(req *SubscriptionRequest, srv ChainBroker_SubscribeServer) error {
	return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (*UnimplementedChainBrokerServer) GetBlockHeader(req *GetBlockHeaderRequest, srv ChainBroker_GetBlockHeaderServer) error {
	return status.Errorf(codes.Unimplemented, "method GetBlockHeader not implemented")
}
func (*UnimplementedChainBrokerServer) GetInterchainTxWrappers(req *GetInterchainTxWrappersRequest, srv ChainBroker_GetInterchainTxWrappersServer) error {
	return status.Errorf(codes.Unimplemented, "method GetInterchainTxWrappers not implemented")
}
func (*UnimplementedChainBrokerServer) SendTransaction(ctx context.Context, req *BxhTransaction) (*TransactionHashMsg, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SendTransaction not implemented")
}
func (*UnimplementedChainBrokerServer) SendView(ctx context.Context, req *BxhTransaction) (*Receipt, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SendView not implemented")
}
func (*UnimplementedChainBrokerServer) GetTransaction(ctx context.Context, req *TransactionHashMsg) (*GetTransactionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetTransaction not implemented")
}
func (*UnimplementedChainBrokerServer) GetReceipt(ctx context.Context, req *TransactionHashMsg) (*Receipt, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetReceipt not implemented")
}
func (*UnimplementedChainBrokerServer) GetBlock(ctx context.Context, req *GetBlockRequest) (*Block, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetBlock not implemented")
}
func (*UnimplementedChainBrokerServer) GetBlocks(ctx context.Context, req *GetBlocksRequest) (*GetBlocksResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetBlocks not implemented")
}
func (*UnimplementedChainBrokerServer) GetBlockHeaders(ctx context.Context, req *GetBlockHeadersRequest) (*GetBlockHeadersResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetBlockHeaders not implemented")
}
func (*UnimplementedChainBrokerServer) GetChainMeta(ctx context.Context, req *Request) (*ChainMeta, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetChainMeta not implemented")
}
func (*UnimplementedChainBrokerServer) GetInfo(ctx context.Context, req *Request) (*Response, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetInfo not implemented")
}
func (*UnimplementedChainBrokerServer) GetAccountBalance(ctx context.Context, req *Address) (*Response, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetAccountBalance not implemented")
}
func (*UnimplementedChainBrokerServer) GetMultiSigns(ctx context.Context, req *GetMultiSignsRequest) (*SignResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetMultiSigns not implemented")
}
func (*UnimplementedChainBrokerServer) GetTPS(ctx context.Context, req *GetTPSRequest) (*Response, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetTPS not implemented")
}
func (*UnimplementedChainBrokerServer) GetPendingNonceByAccount(ctx context.Context, req *Address) (*Response, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPendingNonceByAccount not implemented")
}
func (*UnimplementedChainBrokerServer) DelVPNode(ctx context.Context, req *DelVPNodeRequest) (*Response, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DelVPNode not implemented")
}
func (*UnimplementedChainBrokerServer) CheckMasterSidecar(ctx context.Context, req *Address) (*Response, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CheckMasterSidecar not implemented")
}
func (*UnimplementedChainBrokerServer) SetMasterSidecar(ctx context.Context, req *SidecarInfo) (*Response, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetMasterSidecar not implemented")
}
func (*UnimplementedChainBrokerServer) HeartBeat(ctx context.Context, req *SidecarInfo) (*Response, error) {
	return nil, status.Errorf(codes.Unimplemented, "method HeartBeat not implemented")
}

func RegisterChainBrokerServer(s *grpc.Server, srv ChainBrokerServer) {
	s.RegisterService(&_ChainBroker_serviceDesc, srv)
}

func _ChainBroker_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SubscriptionRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ChainBrokerServer).Subscribe(m, &chainBrokerSubscribeServer{stream})
}

type ChainBroker_SubscribeServer interface {
	Send(*Response) error
	grpc.ServerStream
}

type chainBrokerSubscribeServer struct {
	grpc.ServerStream
}

func (x *chainBrokerSubscribeServer) Send(m *Response) error {
	return x.ServerStream.SendMsg(m)
}

func _ChainBroker_GetBlockHeader_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(GetBlockHeaderRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ChainBrokerServer).GetBlockHeader(m, &chainBrokerGetBlockHeaderServer{stream})
}

type ChainBroker_GetBlockHeaderServer interface {
	Send(*BlockHeader) error
	grpc.ServerStream
}

type chainBrokerGetBlockHeaderServer struct {
	grpc.ServerStream
}

func (x *chainBrokerGetBlockHeaderServer) Send(m *BlockHeader) error {
	return x.ServerStream.SendMsg(m)
}

func _ChainBroker_GetInterchainTxWrappers_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(GetInterchainTxWrappersRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ChainBrokerServer).GetInterchainTxWrappers(m, &chainBrokerGetInterchainTxWrappersServer{stream})
}

type ChainBroker_GetInterchainTxWrappersServer interface {
	Send(*InterchainTxWrappers) error
	grpc.ServerStream
}

type chainBrokerGetInterchainTxWrappersServer struct {
	grpc.ServerStream
}

func (x *chainBrokerGetInterchainTxWrappersServer) Send(m *InterchainTxWrappers) error {
	return x.ServerStream.SendMsg(m)
}

func _ChainBroker_SendTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BxhTransaction)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChainBrokerServer).SendTransaction(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.ChainBroker/SendTransaction",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChainBrokerServer).SendTransaction(ctx, req.(*BxhTransaction))
	}
	return interceptor(ctx, in, info, handler)
}

func _ChainBroker_SendView_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BxhTransaction)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChainBrokerServer).SendView(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.ChainBroker/SendView",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChainBrokerServer).SendView(ctx, req.(*BxhTransaction))
	}
	return interceptor(ctx, in, info, handler)
}

func _ChainBroker_GetTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TransactionHashMsg)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChainBrokerServer).GetTransaction(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.ChainBroker/GetTransaction",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChainBrokerServer).GetTransaction(ctx, req.(*TransactionHashMsg))
	}
	return interceptor(ctx, in, info, handler)
}

func _ChainBroker_GetReceipt_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TransactionHashMsg)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChainBrokerServer).GetReceipt(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.ChainBroker/GetReceipt",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChainBrokerServer).GetReceipt(ctx, req.(*TransactionHashMsg))
	}
	return interceptor(ctx, in, info, handler)
}

func _ChainBroker_GetBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetBlockRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChainBrokerServer).GetBlock(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.ChainBroker/GetBlock",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChainBrokerServer).GetBlock(ctx, req.(*GetBlockRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ChainBroker_GetBlocks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetBlocksRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChainBrokerServer).GetBlocks(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.ChainBroker/GetBlocks",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChainBrokerServer).GetBlocks(ctx, req.(*GetBlocksRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ChainBroker_GetBlockHeaders_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetBlockHeadersRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChainBrokerServer).GetBlockHeaders(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.ChainBroker/GetBlockHeaders",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChainBrokerServer).GetBlockHeaders(ctx, req.(*GetBlockHeadersRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ChainBroker_GetChainMeta_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Request)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChainBrokerServer).GetChainMeta(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.ChainBroker/GetChainMeta",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChainBrokerServer).GetChainMeta(ctx, req.(*Request))
	}
	return interceptor(ctx, in, info, handler)
}

func _ChainBroker_GetInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Request)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChainBrokerServer).GetInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.ChainBroker/GetInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChainBrokerServer).GetInfo(ctx, req.(*Request))
	}
	return interceptor(ctx, in, info, handler)
}

func _ChainBroker_GetAccountBalance_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Address)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChainBrokerServer).GetAccountBalance(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.ChainBroker/GetAccountBalance",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChainBrokerServer).GetAccountBalance(ctx, req.(*Address))
	}
	return interceptor(ctx, in, info, handler)
}

func _ChainBroker_GetMultiSigns_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetMultiSignsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChainBrokerServer).GetMultiSigns(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.ChainBroker/GetMultiSigns",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChainBrokerServer).GetMultiSigns(ctx, req.(*GetMultiSignsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ChainBroker_GetTPS_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetTPSRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChainBrokerServer).GetTPS(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.ChainBroker/GetTPS",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChainBrokerServer).GetTPS(ctx, req.(*GetTPSRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ChainBroker_GetPendingNonceByAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Address)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChainBrokerServer).GetPendingNonceByAccount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.ChainBroker/GetPendingNonceByAccount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChainBrokerServer).GetPendingNonceByAccount(ctx, req.(*Address))
	}
	return interceptor(ctx, in, info, handler)
}

func _ChainBroker_DelVPNode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DelVPNodeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChainBrokerServer).DelVPNode(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.ChainBroker/DelVPNode",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChainBrokerServer).DelVPNode(ctx, req.(*DelVPNodeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ChainBroker_CheckMasterSidecar_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Address)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChainBrokerServer).CheckMasterSidecar(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.ChainBroker/CheckMasterSidecar",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChainBrokerServer).CheckMasterSidecar(ctx, req.(*Address))
	}
	return interceptor(ctx, in, info, handler)
}

func _ChainBroker_SetMasterSidecar_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SidecarInfo)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChainBrokerServer).SetMasterSidecar(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.ChainBroker/SetMasterSidecar",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChainBrokerServer).SetMasterSidecar(ctx, req.(*SidecarInfo))
	}
	return interceptor(ctx, in, info, handler)
}

func _ChainBroker_HeartBeat_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SidecarInfo)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChainBrokerServer).HeartBeat(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.ChainBroker/HeartBeat",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChainBrokerServer).HeartBeat(ctx, req.(*SidecarInfo))
	}
	return interceptor(ctx, in, info, handler)
}

var _ChainBroker_serviceDesc = grpc.ServiceDesc{
	ServiceName: "pb.ChainBroker",
	HandlerType: (*ChainBrokerServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "SendTransaction",
			Handler:    _ChainBroker_SendTransaction_Handler,
		},
		{
			MethodName: "SendView",
			Handler:    _ChainBroker_SendView_Handler,
		},
		{
			MethodName: "GetTransaction",
			Handler:    _ChainBroker_GetTransaction_Handler,
		},
		{
			MethodName: "GetReceipt",
			Handler:    _ChainBroker_GetReceipt_Handler,
		},
		{
			MethodName: "GetBlock",
			Handler:    _ChainBroker_GetBlock_Handler,
		},
		{
			MethodName: "GetBlocks",
			Handler:    _ChainBroker_GetBlocks_Handler,
		},
		{
			MethodName: "GetBlockHeaders",
			Handler:    _ChainBroker_GetBlockHeaders_Handler,
		},
		{
			MethodName: "GetChainMeta",
			Handler:    _ChainBroker_GetChainMeta_Handler,
		},
		{
			MethodName: "GetInfo",
			Handler:    _ChainBroker_GetInfo_Handler,
		},
		{
			MethodName: "GetAccountBalance",
			Handler:    _ChainBroker_GetAccountBalance_Handler,
		},
		{
			MethodName: "GetMultiSigns",
			Handler:    _ChainBroker_GetMultiSigns_Handler,
		},
		{
			MethodName: "GetTPS",
			Handler:    _ChainBroker_GetTPS_Handler,
		},
		{
			MethodName: "GetPendingNonceByAccount",
			Handler:    _ChainBroker_GetPendingNonceByAccount_Handler,
		},
		{
			MethodName: "DelVPNode",
			Handler:    _ChainBroker_DelVPNode_Handler,
		},
		{
			MethodName: "CheckMasterSidecar",
			Handler:    _ChainBroker_CheckMasterSidecar_Handler,
		},
		{
			MethodName: "SetMasterSidecar",
			Handler:    _ChainBroker_SetMasterSidecar_Handler,
		},
		{
			MethodName: "HeartBeat",
			Handler:    _ChainBroker_HeartBeat_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Subscribe",
			Handler:       _ChainBroker_Subscribe_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetBlockHeader",
			Handler:       _ChainBroker_GetBlockHeader_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetInterchainTxWrappers",
			Handler:       _ChainBroker_GetInterchainTxWrappers_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "broker.proto",
}

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

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

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

func (m *GetInterchainTxWrappersRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Pid) > 0 {
		i -= len(m.Pid)
		copy(dAtA[i:], m.Pid)
		i = encodeVarintBroker(dAtA, i, uint64(len(m.Pid)))
		i--
		dAtA[i] = 0x1a
	}
	if m.End != 0 {
		i = encodeVarintBroker(dAtA, i, uint64(m.End))
		i--
		dAtA[i] = 0x10
	}
	if m.Begin != 0 {
		i = encodeVarintBroker(dAtA, i, uint64(m.Begin))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *GetBlockRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Value) > 0 {
		i -= len(m.Value)
		copy(dAtA[i:], m.Value)
		i = encodeVarintBroker(dAtA, i, uint64(len(m.Value)))
		i--
		dAtA[i] = 0x12
	}
	if m.Type != 0 {
		i = encodeVarintBroker(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *SignResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Sign) > 0 {
		for k := range m.Sign {
			v := m.Sign[k]
			baseI := i
			if len(v) > 0 {
				i -= len(v)
				copy(dAtA[i:], v)
				i = encodeVarintBroker(dAtA, i, uint64(len(v)))
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintBroker(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintBroker(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *Address) 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 = encodeVarintBroker(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *GetBlocksResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Blocks) > 0 {
		for iNdEx := len(m.Blocks) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Blocks[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintBroker(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *GetBlockHeadersResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.BlockHeaders) > 0 {
		for iNdEx := len(m.BlockHeaders) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.BlockHeaders[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintBroker(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *SubscriptionRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Extra) > 0 {
		i -= len(m.Extra)
		copy(dAtA[i:], m.Extra)
		i = encodeVarintBroker(dAtA, i, uint64(len(m.Extra)))
		i--
		dAtA[i] = 0x12
	}
	if m.Type != 0 {
		i = encodeVarintBroker(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *GetMultiSignsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Content) > 0 {
		i -= len(m.Content)
		copy(dAtA[i:], m.Content)
		i = encodeVarintBroker(dAtA, i, uint64(len(m.Content)))
		i--
		dAtA[i] = 0x12
	}
	if m.Type != 0 {
		i = encodeVarintBroker(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *VerifiedTx) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Valid {
		i--
		if m.Valid {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.Tx != nil {
		{
			size, err := m.Tx.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintBroker(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *InterchainTxWrapper) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Height != 0 {
		i = encodeVarintBroker(dAtA, i, uint64(m.Height))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Transactions) > 0 {
		for iNdEx := len(m.Transactions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Transactions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintBroker(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.L2Roots) > 0 {
		for iNdEx := len(m.L2Roots) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.L2Roots[iNdEx].Size()
				i -= size
				if _, err := m.L2Roots[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintBroker(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *InterchainTxWrappers) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.InterchainTxWrappers) > 0 {
		for iNdEx := len(m.InterchainTxWrappers) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.InterchainTxWrappers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintBroker(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *SidecarInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Timeout != 0 {
		i = encodeVarintBroker(dAtA, i, uint64(m.Timeout))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Index) > 0 {
		i -= len(m.Index)
		copy(dAtA[i:], m.Index)
		i = encodeVarintBroker(dAtA, i, uint64(len(m.Index)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintBroker(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *CheckSidecarResponse) 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 = encodeVarintBroker(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0x12
	}
	if m.Status != 0 {
		i = encodeVarintBroker(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *GetInterchainTxWrappersRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Begin != 0 {
		n += 1 + sovBroker(uint64(m.Begin))
	}
	if m.End != 0 {
		n += 1 + sovBroker(uint64(m.End))
	}
	l = len(m.Pid)
	if l > 0 {
		n += 1 + l + sovBroker(uint64(l))
	}
	return n
}

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

func (m *GetBlockRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovBroker(uint64(m.Type))
	}
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovBroker(uint64(l))
	}
	return n
}

func (m *Request) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovBroker(uint64(m.Type))
	}
	return n
}

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

func (m *SignResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Sign) > 0 {
		for k, v := range m.Sign {
			_ = k
			_ = v
			l = 0
			if len(v) > 0 {
				l = 1 + len(v) + sovBroker(uint64(len(v)))
			}
			mapEntrySize := 1 + len(k) + sovBroker(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovBroker(uint64(mapEntrySize))
		}
	}
	return n
}

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

func (m *GetBlocksRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Start != 0 {
		n += 1 + sovBroker(uint64(m.Start))
	}
	if m.End != 0 {
		n += 1 + sovBroker(uint64(m.End))
	}
	return n
}

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

func (m *GetBlockHeadersRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Start != 0 {
		n += 1 + sovBroker(uint64(m.Start))
	}
	if m.End != 0 {
		n += 1 + sovBroker(uint64(m.End))
	}
	return n
}

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

func (m *SubscriptionRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovBroker(uint64(m.Type))
	}
	l = len(m.Extra)
	if l > 0 {
		n += 1 + l + sovBroker(uint64(l))
	}
	return n
}

func (m *GetMultiSignsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovBroker(uint64(m.Type))
	}
	l = len(m.Content)
	if l > 0 {
		n += 1 + l + sovBroker(uint64(l))
	}
	return n
}

func (m *GetTransactionResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Tx != nil {
		l = m.Tx.Size()
		n += 1 + l + sovBroker(uint64(l))
	}
	if m.TxMeta != nil {
		l = m.TxMeta.Size()
		n += 1 + l + sovBroker(uint64(l))
	}
	return n
}

func (m *VerifiedTx) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Tx != nil {
		l = m.Tx.Size()
		n += 1 + l + sovBroker(uint64(l))
	}
	if m.Valid {
		n += 2
	}
	return n
}

func (m *InterchainTxWrapper) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.L2Roots) > 0 {
		for _, e := range m.L2Roots {
			l = e.Size()
			n += 1 + l + sovBroker(uint64(l))
		}
	}
	if len(m.Transactions) > 0 {
		for _, e := range m.Transactions {
			l = e.Size()
			n += 1 + l + sovBroker(uint64(l))
		}
	}
	if m.Height != 0 {
		n += 1 + sovBroker(uint64(m.Height))
	}
	return n
}

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

func (m *GetTPSRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Begin != 0 {
		n += 1 + sovBroker(uint64(m.Begin))
	}
	if m.End != 0 {
		n += 1 + sovBroker(uint64(m.End))
	}
	return n
}

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

func (m *SidecarInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovBroker(uint64(l))
	}
	l = len(m.Index)
	if l > 0 {
		n += 1 + l + sovBroker(uint64(l))
	}
	if m.Timeout != 0 {
		n += 1 + sovBroker(uint64(m.Timeout))
	}
	return n
}

func (m *CheckSidecarResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Status != 0 {
		n += 1 + sovBroker(uint64(m.Status))
	}
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovBroker(uint64(l))
	}
	return n
}

func (m *HeartBeatRespones) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Status != 0 {
		n += 1 + sovBroker(uint64(m.Status))
	}
	return n
}

func sovBroker(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozBroker(x uint64) (n int) {
	return sovBroker(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *GetBlockHeaderRequest) 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 ErrIntOverflowBroker
			}
			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: GetBlockHeaderRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetBlockHeaderRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Begin", wireType)
			}
			m.Begin = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Begin |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field End", wireType)
			}
			m.End = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.End |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipBroker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBroker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBroker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetInterchainTxWrappersRequest) 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 ErrIntOverflowBroker
			}
			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: GetInterchainTxWrappersRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetInterchainTxWrappersRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Begin", wireType)
			}
			m.Begin = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Begin |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field End", wireType)
			}
			m.End = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.End |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroker
				}
				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 ErrInvalidLengthBroker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBroker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Pid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBroker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBroker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBroker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TransactionHashMsg) 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 ErrIntOverflowBroker
			}
			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: TransactionHashMsg: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TransactionHashMsg: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxHash", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroker
				}
				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 ErrInvalidLengthBroker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBroker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TxHash = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBroker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBroker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBroker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetBlockRequest) 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 ErrIntOverflowBroker
			}
			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: GetBlockRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetBlockRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= GetBlockRequest_Type(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroker
				}
				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 ErrInvalidLengthBroker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBroker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBroker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBroker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBroker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Request) 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 ErrIntOverflowBroker
			}
			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: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= Request_Type(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipBroker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBroker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBroker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Response) 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 ErrIntOverflowBroker
			}
			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: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: 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 byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthBroker
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthBroker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
			if m.Data == nil {
				m.Data = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBroker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBroker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBroker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SignResponse) 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 ErrIntOverflowBroker
			}
			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: SignResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field sign", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBroker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBroker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Sign == nil {
				m.Sign = make(map[string][]byte)
			}
			var mapkey string
			mapvalue := []byte{}
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowBroker
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowBroker
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthBroker
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthBroker
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapbyteLen uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowBroker
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapbyteLen |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intMapbyteLen := int(mapbyteLen)
					if intMapbyteLen < 0 {
						return ErrInvalidLengthBroker
					}
					postbytesIndex := iNdEx + intMapbyteLen
					if postbytesIndex < 0 {
						return ErrInvalidLengthBroker
					}
					if postbytesIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = make([]byte, mapbyteLen)
					copy(mapvalue, dAtA[iNdEx:postbytesIndex])
					iNdEx = postbytesIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipBroker(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthBroker
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Sign[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBroker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBroker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBroker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Address) 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 ErrIntOverflowBroker
			}
			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: Address: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Address: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowBroker
				}
				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 ErrInvalidLengthBroker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBroker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBroker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBroker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBroker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetMultiSignsRequest) 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 ErrIntOverflowBroker
			}
			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: GetMultiSignsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetMultiSignsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= GetMultiSignsRequest_Type(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Content", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroker
				}
				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 ErrInvalidLengthBroker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBroker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Content = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBroker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBroker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBroker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetTransactionResponse) 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 ErrIntOverflowBroker
			}
			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: GetTransactionResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetTransactionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tx", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBroker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBroker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Tx == nil {
				m.Tx = &BxhTransaction{}
			}
			if err := m.Tx.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxMeta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBroker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBroker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TxMeta == nil {
				m.TxMeta = &TransactionMeta{}
			}
			if err := m.TxMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBroker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBroker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBroker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *VerifiedTx) 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 ErrIntOverflowBroker
			}
			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: VerifiedTx: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: VerifiedTx: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tx", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBroker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBroker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Tx == nil {
				m.Tx = &BxhTransaction{}
			}
			if err := m.Tx.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Valid", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Valid = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipBroker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBroker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBroker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *InterchainTxWrapper) 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 ErrIntOverflowBroker
			}
			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: InterchainTxWrapper: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InterchainTxWrapper: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field L2Roots", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthBroker
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthBroker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_meshplus_bitxhub_kit_types.Hash
			m.L2Roots = append(m.L2Roots, v)
			if err := m.L2Roots[len(m.L2Roots)-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 Transactions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBroker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBroker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Transactions = append(m.Transactions, &VerifiedTx{})
			if err := m.Transactions[len(m.Transactions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
			}
			m.Height = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Height |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipBroker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBroker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBroker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DelVPNodeRequest) 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 ErrIntOverflowBroker
			}
			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: DelVPNodeRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DelVPNodeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroker
				}
				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 ErrInvalidLengthBroker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBroker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Pid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBroker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBroker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBroker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SidecarInfo) 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 ErrIntOverflowBroker
			}
			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: SidecarInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SidecarInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowBroker
				}
				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 ErrInvalidLengthBroker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBroker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			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 ErrIntOverflowBroker
				}
				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 ErrInvalidLengthBroker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBroker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Index = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timeout", wireType)
			}
			m.Timeout = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Timeout |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipBroker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBroker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBroker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CheckSidecarResponse) 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 ErrIntOverflowBroker
			}
			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: CheckSidecarResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CheckSidecarResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= CheckSidecarResponse_Status(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 ErrIntOverflowBroker
				}
				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 ErrInvalidLengthBroker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBroker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBroker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBroker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBroker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HeartBeatRespones) 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 ErrIntOverflowBroker
			}
			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: HeartBeatRespones: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HeartBeatRespones: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= HeartBeatRespones_Status(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipBroker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBroker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBroker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipBroker(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, ErrIntOverflowBroker
			}
			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, ErrIntOverflowBroker
				}
				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, ErrIntOverflowBroker
				}
				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, ErrInvalidLengthBroker
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupBroker
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthBroker
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthBroker        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowBroker          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupBroker = fmt.Errorf("proto: unexpected end of group")
)