// Code generated by protoc-gen-go. DO NOT EDIT.
// source: relay.proto

package types

import (
	fmt "fmt"
	math "math"

	proto "github.com/golang/protobuf/proto"
)

// 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.ProtoPackageIsVersion2 // please upgrade the proto package

type RelayOrderStatus int32

const (
	RelayOrderStatus_init       RelayOrderStatus = 0
	RelayOrderStatus_pending    RelayOrderStatus = 1
	RelayOrderStatus_locking    RelayOrderStatus = 2
	RelayOrderStatus_confirming RelayOrderStatus = 3
	RelayOrderStatus_finished   RelayOrderStatus = 4
	RelayOrderStatus_canceled   RelayOrderStatus = 5
	RelayOrderStatus_timeout    RelayOrderStatus = 6
)

var RelayOrderStatus_name = map[int32]string{
	0: "init",
	1: "pending",
	2: "locking",
	3: "confirming",
	4: "finished",
	5: "canceled",
	6: "timeout",
}

var RelayOrderStatus_value = map[string]int32{
	"init":       0,
	"pending":    1,
	"locking":    2,
	"confirming": 3,
	"finished":   4,
	"canceled":   5,
	"timeout":    6,
}

func (x RelayOrderStatus) String() string {
	return proto.EnumName(RelayOrderStatus_name, int32(x))
}

func (RelayOrderStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_9f69a7d5a802d584, []int{0}
}

type RelayAction struct {
	// Types that are valid to be assigned to Value:
	//	*RelayAction_Create
	//	*RelayAction_Accept
	//	*RelayAction_Revoke
	//	*RelayAction_ConfirmTx
	//	*RelayAction_Verify
	//	*RelayAction_VerifyCli
	//	*RelayAction_BtcHeaders
	Value                isRelayAction_Value `protobuf_oneof:"value"`
	Ty                   int32               `protobuf:"varint,10,opt,name=ty,proto3" json:"ty,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

func (m *RelayAction) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RelayAction.Unmarshal(m, b)
}
func (m *RelayAction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RelayAction.Marshal(b, m, deterministic)
}
func (m *RelayAction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RelayAction.Merge(m, src)
}
func (m *RelayAction) XXX_Size() int {
	return xxx_messageInfo_RelayAction.Size(m)
}
func (m *RelayAction) XXX_DiscardUnknown() {
	xxx_messageInfo_RelayAction.DiscardUnknown(m)
}

var xxx_messageInfo_RelayAction proto.InternalMessageInfo

type isRelayAction_Value interface {
	isRelayAction_Value()
}

type RelayAction_Create struct {
	Create *RelayCreate `protobuf:"bytes,1,opt,name=create,proto3,oneof"`
}

type RelayAction_Accept struct {
	Accept *RelayAccept `protobuf:"bytes,2,opt,name=accept,proto3,oneof"`
}

type RelayAction_Revoke struct {
	Revoke *RelayRevoke `protobuf:"bytes,3,opt,name=revoke,proto3,oneof"`
}

type RelayAction_ConfirmTx struct {
	ConfirmTx *RelayConfirmTx `protobuf:"bytes,4,opt,name=confirmTx,proto3,oneof"`
}

type RelayAction_Verify struct {
	Verify *RelayVerify `protobuf:"bytes,5,opt,name=verify,proto3,oneof"`
}

type RelayAction_VerifyCli struct {
	VerifyCli *RelayVerifyCli `protobuf:"bytes,6,opt,name=verifyCli,proto3,oneof"`
}

type RelayAction_BtcHeaders struct {
	BtcHeaders *BtcHeaders `protobuf:"bytes,7,opt,name=btcHeaders,proto3,oneof"`
}

func (*RelayAction_Create) isRelayAction_Value() {}

func (*RelayAction_Accept) isRelayAction_Value() {}

func (*RelayAction_Revoke) isRelayAction_Value() {}

func (*RelayAction_ConfirmTx) isRelayAction_Value() {}

func (*RelayAction_Verify) isRelayAction_Value() {}

func (*RelayAction_VerifyCli) isRelayAction_Value() {}

func (*RelayAction_BtcHeaders) isRelayAction_Value() {}

func (m *RelayAction) GetValue() isRelayAction_Value {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *RelayAction) GetCreate() *RelayCreate {
	if x, ok := m.GetValue().(*RelayAction_Create); ok {
		return x.Create
	}
	return nil
}

func (m *RelayAction) GetAccept() *RelayAccept {
	if x, ok := m.GetValue().(*RelayAction_Accept); ok {
		return x.Accept
	}
	return nil
}

func (m *RelayAction) GetRevoke() *RelayRevoke {
	if x, ok := m.GetValue().(*RelayAction_Revoke); ok {
		return x.Revoke
	}
	return nil
}

func (m *RelayAction) GetConfirmTx() *RelayConfirmTx {
	if x, ok := m.GetValue().(*RelayAction_ConfirmTx); ok {
		return x.ConfirmTx
	}
	return nil
}

func (m *RelayAction) GetVerify() *RelayVerify {
	if x, ok := m.GetValue().(*RelayAction_Verify); ok {
		return x.Verify
	}
	return nil
}

func (m *RelayAction) GetVerifyCli() *RelayVerifyCli {
	if x, ok := m.GetValue().(*RelayAction_VerifyCli); ok {
		return x.VerifyCli
	}
	return nil
}

func (m *RelayAction) GetBtcHeaders() *BtcHeaders {
	if x, ok := m.GetValue().(*RelayAction_BtcHeaders); ok {
		return x.BtcHeaders
	}
	return nil
}

func (m *RelayAction) GetTy() int32 {
	if m != nil {
		return m.Ty
	}
	return 0
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*RelayAction) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _RelayAction_OneofMarshaler, _RelayAction_OneofUnmarshaler, _RelayAction_OneofSizer, []interface{}{
		(*RelayAction_Create)(nil),
		(*RelayAction_Accept)(nil),
		(*RelayAction_Revoke)(nil),
		(*RelayAction_ConfirmTx)(nil),
		(*RelayAction_Verify)(nil),
		(*RelayAction_VerifyCli)(nil),
		(*RelayAction_BtcHeaders)(nil),
	}
}

func _RelayAction_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*RelayAction)
	// value
	switch x := m.Value.(type) {
	case *RelayAction_Create:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Create); err != nil {
			return err
		}
	case *RelayAction_Accept:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Accept); err != nil {
			return err
		}
	case *RelayAction_Revoke:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Revoke); err != nil {
			return err
		}
	case *RelayAction_ConfirmTx:
		b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ConfirmTx); err != nil {
			return err
		}
	case *RelayAction_Verify:
		b.EncodeVarint(5<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Verify); err != nil {
			return err
		}
	case *RelayAction_VerifyCli:
		b.EncodeVarint(6<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.VerifyCli); err != nil {
			return err
		}
	case *RelayAction_BtcHeaders:
		b.EncodeVarint(7<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.BtcHeaders); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("RelayAction.Value has unexpected type %T", x)
	}
	return nil
}

func _RelayAction_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*RelayAction)
	switch tag {
	case 1: // value.create
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(RelayCreate)
		err := b.DecodeMessage(msg)
		m.Value = &RelayAction_Create{msg}
		return true, err
	case 2: // value.accept
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(RelayAccept)
		err := b.DecodeMessage(msg)
		m.Value = &RelayAction_Accept{msg}
		return true, err
	case 3: // value.revoke
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(RelayRevoke)
		err := b.DecodeMessage(msg)
		m.Value = &RelayAction_Revoke{msg}
		return true, err
	case 4: // value.confirmTx
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(RelayConfirmTx)
		err := b.DecodeMessage(msg)
		m.Value = &RelayAction_ConfirmTx{msg}
		return true, err
	case 5: // value.verify
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(RelayVerify)
		err := b.DecodeMessage(msg)
		m.Value = &RelayAction_Verify{msg}
		return true, err
	case 6: // value.verifyCli
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(RelayVerifyCli)
		err := b.DecodeMessage(msg)
		m.Value = &RelayAction_VerifyCli{msg}
		return true, err
	case 7: // value.btcHeaders
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(BtcHeaders)
		err := b.DecodeMessage(msg)
		m.Value = &RelayAction_BtcHeaders{msg}
		return true, err
	default:
		return false, nil
	}
}

func _RelayAction_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*RelayAction)
	// value
	switch x := m.Value.(type) {
	case *RelayAction_Create:
		s := proto.Size(x.Create)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *RelayAction_Accept:
		s := proto.Size(x.Accept)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *RelayAction_Revoke:
		s := proto.Size(x.Revoke)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *RelayAction_ConfirmTx:
		s := proto.Size(x.ConfirmTx)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *RelayAction_Verify:
		s := proto.Size(x.Verify)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *RelayAction_VerifyCli:
		s := proto.Size(x.VerifyCli)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *RelayAction_BtcHeaders:
		s := proto.Size(x.BtcHeaders)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type RelayOrder struct {
	Id                   string           `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Status               RelayOrderStatus `protobuf:"varint,2,opt,name=status,proto3,enum=types.RelayOrderStatus" json:"status,omitempty"`
	PreStatus            RelayOrderStatus `protobuf:"varint,3,opt,name=preStatus,proto3,enum=types.RelayOrderStatus" json:"preStatus,omitempty"`
	Amount               uint64           `protobuf:"varint,4,opt,name=amount,proto3" json:"amount,omitempty"`
	CreaterAddr          string           `protobuf:"bytes,5,opt,name=createrAddr,proto3" json:"createrAddr,omitempty"`
	CoinOperation        uint32           `protobuf:"varint,6,opt,name=coinOperation,proto3" json:"coinOperation,omitempty"`
	Coin                 string           `protobuf:"bytes,7,opt,name=coin,proto3" json:"coin,omitempty"`
	CoinAmount           uint64           `protobuf:"varint,8,opt,name=coinAmount,proto3" json:"coinAmount,omitempty"`
	CoinAddr             string           `protobuf:"bytes,9,opt,name=coinAddr,proto3" json:"coinAddr,omitempty"`
	CoinTxHash           string           `protobuf:"bytes,10,opt,name=coinTxHash,proto3" json:"coinTxHash,omitempty"`
	CreateTime           int64            `protobuf:"varint,11,opt,name=createTime,proto3" json:"createTime,omitempty"`
	AcceptAddr           string           `protobuf:"bytes,12,opt,name=acceptAddr,proto3" json:"acceptAddr,omitempty"`
	AcceptTime           int64            `protobuf:"varint,13,opt,name=acceptTime,proto3" json:"acceptTime,omitempty"`
	ConfirmTime          int64            `protobuf:"varint,14,opt,name=confirmTime,proto3" json:"confirmTime,omitempty"`
	FinishTime           int64            `protobuf:"varint,15,opt,name=finishTime,proto3" json:"finishTime,omitempty"`
	FinishTxHash         string           `protobuf:"bytes,16,opt,name=finishTxHash,proto3" json:"finishTxHash,omitempty"`
	Height               int64            `protobuf:"varint,17,opt,name=height,proto3" json:"height,omitempty"`
	CoinHeight           uint64           `protobuf:"varint,18,opt,name=coinHeight,proto3" json:"coinHeight,omitempty"`
	CoinWaits            uint32           `protobuf:"varint,19,opt,name=coinWaits,proto3" json:"coinWaits,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

func (m *RelayOrder) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RelayOrder.Unmarshal(m, b)
}
func (m *RelayOrder) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RelayOrder.Marshal(b, m, deterministic)
}
func (m *RelayOrder) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RelayOrder.Merge(m, src)
}
func (m *RelayOrder) XXX_Size() int {
	return xxx_messageInfo_RelayOrder.Size(m)
}
func (m *RelayOrder) XXX_DiscardUnknown() {
	xxx_messageInfo_RelayOrder.DiscardUnknown(m)
}

var xxx_messageInfo_RelayOrder proto.InternalMessageInfo

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

func (m *RelayOrder) GetStatus() RelayOrderStatus {
	if m != nil {
		return m.Status
	}
	return RelayOrderStatus_init
}

func (m *RelayOrder) GetPreStatus() RelayOrderStatus {
	if m != nil {
		return m.PreStatus
	}
	return RelayOrderStatus_init
}

func (m *RelayOrder) GetAmount() uint64 {
	if m != nil {
		return m.Amount
	}
	return 0
}

func (m *RelayOrder) GetCreaterAddr() string {
	if m != nil {
		return m.CreaterAddr
	}
	return ""
}

func (m *RelayOrder) GetCoinOperation() uint32 {
	if m != nil {
		return m.CoinOperation
	}
	return 0
}

func (m *RelayOrder) GetCoin() string {
	if m != nil {
		return m.Coin
	}
	return ""
}

func (m *RelayOrder) GetCoinAmount() uint64 {
	if m != nil {
		return m.CoinAmount
	}
	return 0
}

func (m *RelayOrder) GetCoinAddr() string {
	if m != nil {
		return m.CoinAddr
	}
	return ""
}

func (m *RelayOrder) GetCoinTxHash() string {
	if m != nil {
		return m.CoinTxHash
	}
	return ""
}

func (m *RelayOrder) GetCreateTime() int64 {
	if m != nil {
		return m.CreateTime
	}
	return 0
}

func (m *RelayOrder) GetAcceptAddr() string {
	if m != nil {
		return m.AcceptAddr
	}
	return ""
}

func (m *RelayOrder) GetAcceptTime() int64 {
	if m != nil {
		return m.AcceptTime
	}
	return 0
}

func (m *RelayOrder) GetConfirmTime() int64 {
	if m != nil {
		return m.ConfirmTime
	}
	return 0
}

func (m *RelayOrder) GetFinishTime() int64 {
	if m != nil {
		return m.FinishTime
	}
	return 0
}

func (m *RelayOrder) GetFinishTxHash() string {
	if m != nil {
		return m.FinishTxHash
	}
	return ""
}

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

func (m *RelayOrder) GetCoinHeight() uint64 {
	if m != nil {
		return m.CoinHeight
	}
	return 0
}

func (m *RelayOrder) GetCoinWaits() uint32 {
	if m != nil {
		return m.CoinWaits
	}
	return 0
}

type RelayCreate struct {
	Operation            uint32   `protobuf:"varint,1,opt,name=operation,proto3" json:"operation,omitempty"`
	Coin                 string   `protobuf:"bytes,2,opt,name=coin,proto3" json:"coin,omitempty"`
	Amount               uint64   `protobuf:"varint,3,opt,name=amount,proto3" json:"amount,omitempty"`
	Addr                 string   `protobuf:"bytes,4,opt,name=addr,proto3" json:"addr,omitempty"`
	BtyAmount            uint64   `protobuf:"varint,5,opt,name=btyAmount,proto3" json:"btyAmount,omitempty"`
	CoinWaits            uint32   `protobuf:"varint,6,opt,name=coinWaits,proto3" json:"coinWaits,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *RelayCreate) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RelayCreate.Unmarshal(m, b)
}
func (m *RelayCreate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RelayCreate.Marshal(b, m, deterministic)
}
func (m *RelayCreate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RelayCreate.Merge(m, src)
}
func (m *RelayCreate) XXX_Size() int {
	return xxx_messageInfo_RelayCreate.Size(m)
}
func (m *RelayCreate) XXX_DiscardUnknown() {
	xxx_messageInfo_RelayCreate.DiscardUnknown(m)
}

var xxx_messageInfo_RelayCreate proto.InternalMessageInfo

func (m *RelayCreate) GetOperation() uint32 {
	if m != nil {
		return m.Operation
	}
	return 0
}

func (m *RelayCreate) GetCoin() string {
	if m != nil {
		return m.Coin
	}
	return ""
}

func (m *RelayCreate) GetAmount() uint64 {
	if m != nil {
		return m.Amount
	}
	return 0
}

func (m *RelayCreate) GetAddr() string {
	if m != nil {
		return m.Addr
	}
	return ""
}

func (m *RelayCreate) GetBtyAmount() uint64 {
	if m != nil {
		return m.BtyAmount
	}
	return 0
}

func (m *RelayCreate) GetCoinWaits() uint32 {
	if m != nil {
		return m.CoinWaits
	}
	return 0
}

type RelayAccept struct {
	OrderId              string   `protobuf:"bytes,1,opt,name=orderId,proto3" json:"orderId,omitempty"`
	CoinAddr             string   `protobuf:"bytes,2,opt,name=coinAddr,proto3" json:"coinAddr,omitempty"`
	CoinWaits            uint32   `protobuf:"varint,3,opt,name=coinWaits,proto3" json:"coinWaits,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *RelayAccept) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RelayAccept.Unmarshal(m, b)
}
func (m *RelayAccept) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RelayAccept.Marshal(b, m, deterministic)
}
func (m *RelayAccept) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RelayAccept.Merge(m, src)
}
func (m *RelayAccept) XXX_Size() int {
	return xxx_messageInfo_RelayAccept.Size(m)
}
func (m *RelayAccept) XXX_DiscardUnknown() {
	xxx_messageInfo_RelayAccept.DiscardUnknown(m)
}

var xxx_messageInfo_RelayAccept proto.InternalMessageInfo

func (m *RelayAccept) GetOrderId() string {
	if m != nil {
		return m.OrderId
	}
	return ""
}

func (m *RelayAccept) GetCoinAddr() string {
	if m != nil {
		return m.CoinAddr
	}
	return ""
}

func (m *RelayAccept) GetCoinWaits() uint32 {
	if m != nil {
		return m.CoinWaits
	}
	return 0
}

type RelayRevoke struct {
	OrderId              string   `protobuf:"bytes,1,opt,name=orderId,proto3" json:"orderId,omitempty"`
	Target               uint32   `protobuf:"varint,2,opt,name=target,proto3" json:"target,omitempty"`
	Action               uint32   `protobuf:"varint,3,opt,name=action,proto3" json:"action,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *RelayRevoke) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RelayRevoke.Unmarshal(m, b)
}
func (m *RelayRevoke) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RelayRevoke.Marshal(b, m, deterministic)
}
func (m *RelayRevoke) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RelayRevoke.Merge(m, src)
}
func (m *RelayRevoke) XXX_Size() int {
	return xxx_messageInfo_RelayRevoke.Size(m)
}
func (m *RelayRevoke) XXX_DiscardUnknown() {
	xxx_messageInfo_RelayRevoke.DiscardUnknown(m)
}

var xxx_messageInfo_RelayRevoke proto.InternalMessageInfo

func (m *RelayRevoke) GetOrderId() string {
	if m != nil {
		return m.OrderId
	}
	return ""
}

func (m *RelayRevoke) GetTarget() uint32 {
	if m != nil {
		return m.Target
	}
	return 0
}

func (m *RelayRevoke) GetAction() uint32 {
	if m != nil {
		return m.Action
	}
	return 0
}

//客户只用交易hash提交， 验证需要的其他信息由relayd提供
type RelayConfirmTx struct {
	OrderId              string   `protobuf:"bytes,1,opt,name=orderId,proto3" json:"orderId,omitempty"`
	TxHash               string   `protobuf:"bytes,2,opt,name=txHash,proto3" json:"txHash,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *RelayConfirmTx) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RelayConfirmTx.Unmarshal(m, b)
}
func (m *RelayConfirmTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RelayConfirmTx.Marshal(b, m, deterministic)
}
func (m *RelayConfirmTx) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RelayConfirmTx.Merge(m, src)
}
func (m *RelayConfirmTx) XXX_Size() int {
	return xxx_messageInfo_RelayConfirmTx.Size(m)
}
func (m *RelayConfirmTx) XXX_DiscardUnknown() {
	xxx_messageInfo_RelayConfirmTx.DiscardUnknown(m)
}

var xxx_messageInfo_RelayConfirmTx proto.InternalMessageInfo

func (m *RelayConfirmTx) GetOrderId() string {
	if m != nil {
		return m.OrderId
	}
	return ""
}

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

// relayd提供验证信息
type RelayVerify struct {
	OrderId              string          `protobuf:"bytes,1,opt,name=orderId,proto3" json:"orderId,omitempty"`
	Tx                   *BtcTransaction `protobuf:"bytes,2,opt,name=tx,proto3" json:"tx,omitempty"`
	Spv                  *BtcSpv         `protobuf:"bytes,3,opt,name=spv,proto3" json:"spv,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

func (m *RelayVerify) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RelayVerify.Unmarshal(m, b)
}
func (m *RelayVerify) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RelayVerify.Marshal(b, m, deterministic)
}
func (m *RelayVerify) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RelayVerify.Merge(m, src)
}
func (m *RelayVerify) XXX_Size() int {
	return xxx_messageInfo_RelayVerify.Size(m)
}
func (m *RelayVerify) XXX_DiscardUnknown() {
	xxx_messageInfo_RelayVerify.DiscardUnknown(m)
}

var xxx_messageInfo_RelayVerify proto.InternalMessageInfo

func (m *RelayVerify) GetOrderId() string {
	if m != nil {
		return m.OrderId
	}
	return ""
}

func (m *RelayVerify) GetTx() *BtcTransaction {
	if m != nil {
		return m.Tx
	}
	return nil
}

func (m *RelayVerify) GetSpv() *BtcSpv {
	if m != nil {
		return m.Spv
	}
	return nil
}

type RelayVerifyCli struct {
	OrderId              string   `protobuf:"bytes,1,opt,name=orderId,proto3" json:"orderId,omitempty"`
	RawTx                string   `protobuf:"bytes,2,opt,name=rawTx,proto3" json:"rawTx,omitempty"`
	TxIndex              uint32   `protobuf:"varint,3,opt,name=txIndex,proto3" json:"txIndex,omitempty"`
	MerkBranch           string   `protobuf:"bytes,4,opt,name=merkBranch,proto3" json:"merkBranch,omitempty"`
	BlockHash            string   `protobuf:"bytes,5,opt,name=blockHash,proto3" json:"blockHash,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *RelayVerifyCli) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RelayVerifyCli.Unmarshal(m, b)
}
func (m *RelayVerifyCli) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RelayVerifyCli.Marshal(b, m, deterministic)
}
func (m *RelayVerifyCli) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RelayVerifyCli.Merge(m, src)
}
func (m *RelayVerifyCli) XXX_Size() int {
	return xxx_messageInfo_RelayVerifyCli.Size(m)
}
func (m *RelayVerifyCli) XXX_DiscardUnknown() {
	xxx_messageInfo_RelayVerifyCli.DiscardUnknown(m)
}

var xxx_messageInfo_RelayVerifyCli proto.InternalMessageInfo

func (m *RelayVerifyCli) GetOrderId() string {
	if m != nil {
		return m.OrderId
	}
	return ""
}

func (m *RelayVerifyCli) GetRawTx() string {
	if m != nil {
		return m.RawTx
	}
	return ""
}

func (m *RelayVerifyCli) GetTxIndex() uint32 {
	if m != nil {
		return m.TxIndex
	}
	return 0
}

func (m *RelayVerifyCli) GetMerkBranch() string {
	if m != nil {
		return m.MerkBranch
	}
	return ""
}

func (m *RelayVerifyCli) GetBlockHash() string {
	if m != nil {
		return m.BlockHash
	}
	return ""
}

type BtcHeader struct {
	Hash                 string   `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
	Confirmations        uint64   `protobuf:"varint,2,opt,name=confirmations,proto3" json:"confirmations,omitempty"`
	Height               uint64   `protobuf:"varint,3,opt,name=height,proto3" json:"height,omitempty"`
	Version              uint32   `protobuf:"varint,4,opt,name=version,proto3" json:"version,omitempty"`
	MerkleRoot           string   `protobuf:"bytes,5,opt,name=merkleRoot,proto3" json:"merkleRoot,omitempty"`
	Time                 int64    `protobuf:"varint,6,opt,name=time,proto3" json:"time,omitempty"`
	Nonce                uint64   `protobuf:"varint,7,opt,name=nonce,proto3" json:"nonce,omitempty"`
	Bits                 int64    `protobuf:"varint,8,opt,name=bits,proto3" json:"bits,omitempty"`
	Difficulty           int64    `protobuf:"varint,9,opt,name=difficulty,proto3" json:"difficulty,omitempty"`
	PreviousHash         string   `protobuf:"bytes,10,opt,name=previousHash,proto3" json:"previousHash,omitempty"`
	NextHash             string   `protobuf:"bytes,11,opt,name=nextHash,proto3" json:"nextHash,omitempty"`
	IsReset              bool     `protobuf:"varint,12,opt,name=isReset,proto3" json:"isReset,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *BtcHeader) Reset()         { *m = BtcHeader{} }
func (m *BtcHeader) String() string { return proto.CompactTextString(m) }
func (*BtcHeader) ProtoMessage()    {}
func (*BtcHeader) Descriptor() ([]byte, []int) {
	return fileDescriptor_9f69a7d5a802d584, []int{8}
}

func (m *BtcHeader) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_BtcHeader.Unmarshal(m, b)
}
func (m *BtcHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_BtcHeader.Marshal(b, m, deterministic)
}
func (m *BtcHeader) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BtcHeader.Merge(m, src)
}
func (m *BtcHeader) XXX_Size() int {
	return xxx_messageInfo_BtcHeader.Size(m)
}
func (m *BtcHeader) XXX_DiscardUnknown() {
	xxx_messageInfo_BtcHeader.DiscardUnknown(m)
}

var xxx_messageInfo_BtcHeader proto.InternalMessageInfo

func (m *BtcHeader) GetHash() string {
	if m != nil {
		return m.Hash
	}
	return ""
}

func (m *BtcHeader) GetConfirmations() uint64 {
	if m != nil {
		return m.Confirmations
	}
	return 0
}

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

func (m *BtcHeader) GetVersion() uint32 {
	if m != nil {
		return m.Version
	}
	return 0
}

func (m *BtcHeader) GetMerkleRoot() string {
	if m != nil {
		return m.MerkleRoot
	}
	return ""
}

func (m *BtcHeader) GetTime() int64 {
	if m != nil {
		return m.Time
	}
	return 0
}

func (m *BtcHeader) GetNonce() uint64 {
	if m != nil {
		return m.Nonce
	}
	return 0
}

func (m *BtcHeader) GetBits() int64 {
	if m != nil {
		return m.Bits
	}
	return 0
}

func (m *BtcHeader) GetDifficulty() int64 {
	if m != nil {
		return m.Difficulty
	}
	return 0
}

func (m *BtcHeader) GetPreviousHash() string {
	if m != nil {
		return m.PreviousHash
	}
	return ""
}

func (m *BtcHeader) GetNextHash() string {
	if m != nil {
		return m.NextHash
	}
	return ""
}

func (m *BtcHeader) GetIsReset() bool {
	if m != nil {
		return m.IsReset
	}
	return false
}

type BtcHeaders struct {
	BtcHeader            []*BtcHeader `protobuf:"bytes,1,rep,name=btcHeader,proto3" json:"btcHeader,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *BtcHeaders) Reset()         { *m = BtcHeaders{} }
func (m *BtcHeaders) String() string { return proto.CompactTextString(m) }
func (*BtcHeaders) ProtoMessage()    {}
func (*BtcHeaders) Descriptor() ([]byte, []int) {
	return fileDescriptor_9f69a7d5a802d584, []int{9}
}

func (m *BtcHeaders) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_BtcHeaders.Unmarshal(m, b)
}
func (m *BtcHeaders) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_BtcHeaders.Marshal(b, m, deterministic)
}
func (m *BtcHeaders) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BtcHeaders.Merge(m, src)
}
func (m *BtcHeaders) XXX_Size() int {
	return xxx_messageInfo_BtcHeaders.Size(m)
}
func (m *BtcHeaders) XXX_DiscardUnknown() {
	xxx_messageInfo_BtcHeaders.DiscardUnknown(m)
}

var xxx_messageInfo_BtcHeaders proto.InternalMessageInfo

func (m *BtcHeaders) GetBtcHeader() []*BtcHeader {
	if m != nil {
		return m.BtcHeader
	}
	return nil
}

type BtcTransaction struct {
	Hash                 string   `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
	BlockHeight          uint64   `protobuf:"varint,2,opt,name=blockHeight,proto3" json:"blockHeight,omitempty"`
	Vin                  []*Vin   `protobuf:"bytes,3,rep,name=vin,proto3" json:"vin,omitempty"`
	Vout                 []*Vout  `protobuf:"bytes,4,rep,name=vout,proto3" json:"vout,omitempty"`
	Time                 int64    `protobuf:"varint,5,opt,name=time,proto3" json:"time,omitempty"`
	Confirmations        uint64   `protobuf:"varint,6,opt,name=confirmations,proto3" json:"confirmations,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *BtcTransaction) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_BtcTransaction.Unmarshal(m, b)
}
func (m *BtcTransaction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_BtcTransaction.Marshal(b, m, deterministic)
}
func (m *BtcTransaction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BtcTransaction.Merge(m, src)
}
func (m *BtcTransaction) XXX_Size() int {
	return xxx_messageInfo_BtcTransaction.Size(m)
}
func (m *BtcTransaction) XXX_DiscardUnknown() {
	xxx_messageInfo_BtcTransaction.DiscardUnknown(m)
}

var xxx_messageInfo_BtcTransaction proto.InternalMessageInfo

func (m *BtcTransaction) GetHash() string {
	if m != nil {
		return m.Hash
	}
	return ""
}

func (m *BtcTransaction) GetBlockHeight() uint64 {
	if m != nil {
		return m.BlockHeight
	}
	return 0
}

func (m *BtcTransaction) GetVin() []*Vin {
	if m != nil {
		return m.Vin
	}
	return nil
}

func (m *BtcTransaction) GetVout() []*Vout {
	if m != nil {
		return m.Vout
	}
	return nil
}

func (m *BtcTransaction) GetTime() int64 {
	if m != nil {
		return m.Time
	}
	return 0
}

func (m *BtcTransaction) GetConfirmations() uint64 {
	if m != nil {
		return m.Confirmations
	}
	return 0
}

type Vin struct {
	Address              string   `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	Value                uint64   `protobuf:"varint,2,opt,name=Value,proto3" json:"Value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *Vin) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Vin.Unmarshal(m, b)
}
func (m *Vin) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Vin.Marshal(b, m, deterministic)
}
func (m *Vin) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Vin.Merge(m, src)
}
func (m *Vin) XXX_Size() int {
	return xxx_messageInfo_Vin.Size(m)
}
func (m *Vin) XXX_DiscardUnknown() {
	xxx_messageInfo_Vin.DiscardUnknown(m)
}

var xxx_messageInfo_Vin proto.InternalMessageInfo

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

func (m *Vin) GetValue() uint64 {
	if m != nil {
		return m.Value
	}
	return 0
}

type Vout struct {
	Coinbase             bool     `protobuf:"varint,1,opt,name=coinbase,proto3" json:"coinbase,omitempty"`
	Address              string   `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
	Value                uint64   `protobuf:"varint,3,opt,name=Value,proto3" json:"Value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *Vout) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Vout.Unmarshal(m, b)
}
func (m *Vout) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Vout.Marshal(b, m, deterministic)
}
func (m *Vout) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Vout.Merge(m, src)
}
func (m *Vout) XXX_Size() int {
	return xxx_messageInfo_Vout.Size(m)
}
func (m *Vout) XXX_DiscardUnknown() {
	xxx_messageInfo_Vout.DiscardUnknown(m)
}

var xxx_messageInfo_Vout proto.InternalMessageInfo

func (m *Vout) GetCoinbase() bool {
	if m != nil {
		return m.Coinbase
	}
	return false
}

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

func (m *Vout) GetValue() uint64 {
	if m != nil {
		return m.Value
	}
	return 0
}

type BtcSpv struct {
	Hash                 string   `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
	Time                 int64    `protobuf:"varint,2,opt,name=time,proto3" json:"time,omitempty"`
	Height               uint64   `protobuf:"varint,3,opt,name=height,proto3" json:"height,omitempty"`
	BlockHash            string   `protobuf:"bytes,4,opt,name=blockHash,proto3" json:"blockHash,omitempty"`
	TxIndex              uint32   `protobuf:"varint,5,opt,name=txIndex,proto3" json:"txIndex,omitempty"`
	BranchProof          [][]byte `protobuf:"bytes,6,rep,name=branchProof,proto3" json:"branchProof,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *BtcSpv) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_BtcSpv.Unmarshal(m, b)
}
func (m *BtcSpv) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_BtcSpv.Marshal(b, m, deterministic)
}
func (m *BtcSpv) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BtcSpv.Merge(m, src)
}
func (m *BtcSpv) XXX_Size() int {
	return xxx_messageInfo_BtcSpv.Size(m)
}
func (m *BtcSpv) XXX_DiscardUnknown() {
	xxx_messageInfo_BtcSpv.DiscardUnknown(m)
}

var xxx_messageInfo_BtcSpv proto.InternalMessageInfo

func (m *BtcSpv) GetHash() string {
	if m != nil {
		return m.Hash
	}
	return ""
}

func (m *BtcSpv) GetTime() int64 {
	if m != nil {
		return m.Time
	}
	return 0
}

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

func (m *BtcSpv) GetBlockHash() string {
	if m != nil {
		return m.BlockHash
	}
	return ""
}

func (m *BtcSpv) GetTxIndex() uint32 {
	if m != nil {
		return m.TxIndex
	}
	return 0
}

func (m *BtcSpv) GetBranchProof() [][]byte {
	if m != nil {
		return m.BranchProof
	}
	return nil
}

type RelayLastRcvBtcHeader struct {
	Header               *BtcHeader `protobuf:"bytes,1,opt,name=Header,proto3" json:"Header,omitempty"`
	BaseHeight           uint64     `protobuf:"varint,2,opt,name=baseHeight,proto3" json:"baseHeight,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

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

func (m *RelayLastRcvBtcHeader) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RelayLastRcvBtcHeader.Unmarshal(m, b)
}
func (m *RelayLastRcvBtcHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RelayLastRcvBtcHeader.Marshal(b, m, deterministic)
}
func (m *RelayLastRcvBtcHeader) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RelayLastRcvBtcHeader.Merge(m, src)
}
func (m *RelayLastRcvBtcHeader) XXX_Size() int {
	return xxx_messageInfo_RelayLastRcvBtcHeader.Size(m)
}
func (m *RelayLastRcvBtcHeader) XXX_DiscardUnknown() {
	xxx_messageInfo_RelayLastRcvBtcHeader.DiscardUnknown(m)
}

var xxx_messageInfo_RelayLastRcvBtcHeader proto.InternalMessageInfo

func (m *RelayLastRcvBtcHeader) GetHeader() *BtcHeader {
	if m != nil {
		return m.Header
	}
	return nil
}

func (m *RelayLastRcvBtcHeader) GetBaseHeight() uint64 {
	if m != nil {
		return m.BaseHeight
	}
	return 0
}

type ReceiptRelayRcvBTCHeaders struct {
	Headers              []*BtcHeader `protobuf:"bytes,1,rep,name=headers,proto3" json:"headers,omitempty"`
	LastHeight           uint64       `protobuf:"varint,2,opt,name=lastHeight,proto3" json:"lastHeight,omitempty"`
	NewHeight            uint64       `protobuf:"varint,3,opt,name=newHeight,proto3" json:"newHeight,omitempty"`
	LastBaseHeight       uint64       `protobuf:"varint,4,opt,name=lastBaseHeight,proto3" json:"lastBaseHeight,omitempty"`
	NewBaseHeight        uint64       `protobuf:"varint,5,opt,name=newBaseHeight,proto3" json:"newBaseHeight,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

func (m *ReceiptRelayRcvBTCHeaders) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReceiptRelayRcvBTCHeaders.Unmarshal(m, b)
}
func (m *ReceiptRelayRcvBTCHeaders) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReceiptRelayRcvBTCHeaders.Marshal(b, m, deterministic)
}
func (m *ReceiptRelayRcvBTCHeaders) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReceiptRelayRcvBTCHeaders.Merge(m, src)
}
func (m *ReceiptRelayRcvBTCHeaders) XXX_Size() int {
	return xxx_messageInfo_ReceiptRelayRcvBTCHeaders.Size(m)
}
func (m *ReceiptRelayRcvBTCHeaders) XXX_DiscardUnknown() {
	xxx_messageInfo_ReceiptRelayRcvBTCHeaders.DiscardUnknown(m)
}

var xxx_messageInfo_ReceiptRelayRcvBTCHeaders proto.InternalMessageInfo

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

func (m *ReceiptRelayRcvBTCHeaders) GetLastHeight() uint64 {
	if m != nil {
		return m.LastHeight
	}
	return 0
}

func (m *ReceiptRelayRcvBTCHeaders) GetNewHeight() uint64 {
	if m != nil {
		return m.NewHeight
	}
	return 0
}

func (m *ReceiptRelayRcvBTCHeaders) GetLastBaseHeight() uint64 {
	if m != nil {
		return m.LastBaseHeight
	}
	return 0
}

func (m *ReceiptRelayRcvBTCHeaders) GetNewBaseHeight() uint64 {
	if m != nil {
		return m.NewBaseHeight
	}
	return 0
}

type ReceiptRelayLog struct {
	OrderId              string   `protobuf:"bytes,1,opt,name=orderId,proto3" json:"orderId,omitempty"`
	CurStatus            string   `protobuf:"bytes,2,opt,name=curStatus,proto3" json:"curStatus,omitempty"`
	PreStatus            string   `protobuf:"bytes,3,opt,name=preStatus,proto3" json:"preStatus,omitempty"`
	TxAmount             string   `protobuf:"bytes,4,opt,name=txAmount,proto3" json:"txAmount,omitempty"`
	CreaterAddr          string   `protobuf:"bytes,5,opt,name=createrAddr,proto3" json:"createrAddr,omitempty"`
	CoinOperation        string   `protobuf:"bytes,6,opt,name=coinOperation,proto3" json:"coinOperation,omitempty"`
	Coin                 string   `protobuf:"bytes,7,opt,name=coin,proto3" json:"coin,omitempty"`
	CoinAmount           string   `protobuf:"bytes,8,opt,name=coinAmount,proto3" json:"coinAmount,omitempty"`
	CoinAddr             string   `protobuf:"bytes,9,opt,name=coinAddr,proto3" json:"coinAddr,omitempty"`
	CoinTxHash           string   `protobuf:"bytes,10,opt,name=coinTxHash,proto3" json:"coinTxHash,omitempty"`
	CreateTime           int64    `protobuf:"varint,11,opt,name=createTime,proto3" json:"createTime,omitempty"`
	AcceptAddr           string   `protobuf:"bytes,12,opt,name=acceptAddr,proto3" json:"acceptAddr,omitempty"`
	AcceptTime           int64    `protobuf:"varint,13,opt,name=acceptTime,proto3" json:"acceptTime,omitempty"`
	ConfirmTime          int64    `protobuf:"varint,14,opt,name=confirmTime,proto3" json:"confirmTime,omitempty"`
	FinishTime           int64    `protobuf:"varint,15,opt,name=finishTime,proto3" json:"finishTime,omitempty"`
	FinishTxHash         string   `protobuf:"bytes,16,opt,name=finishTxHash,proto3" json:"finishTxHash,omitempty"`
	CoinHeight           uint64   `protobuf:"varint,17,opt,name=coinHeight,proto3" json:"coinHeight,omitempty"`
	CoinWaits            uint32   `protobuf:"varint,18,opt,name=coinWaits,proto3" json:"coinWaits,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *ReceiptRelayLog) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReceiptRelayLog.Unmarshal(m, b)
}
func (m *ReceiptRelayLog) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReceiptRelayLog.Marshal(b, m, deterministic)
}
func (m *ReceiptRelayLog) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReceiptRelayLog.Merge(m, src)
}
func (m *ReceiptRelayLog) XXX_Size() int {
	return xxx_messageInfo_ReceiptRelayLog.Size(m)
}
func (m *ReceiptRelayLog) XXX_DiscardUnknown() {
	xxx_messageInfo_ReceiptRelayLog.DiscardUnknown(m)
}

var xxx_messageInfo_ReceiptRelayLog proto.InternalMessageInfo

func (m *ReceiptRelayLog) GetOrderId() string {
	if m != nil {
		return m.OrderId
	}
	return ""
}

func (m *ReceiptRelayLog) GetCurStatus() string {
	if m != nil {
		return m.CurStatus
	}
	return ""
}

func (m *ReceiptRelayLog) GetPreStatus() string {
	if m != nil {
		return m.PreStatus
	}
	return ""
}

func (m *ReceiptRelayLog) GetTxAmount() string {
	if m != nil {
		return m.TxAmount
	}
	return ""
}

func (m *ReceiptRelayLog) GetCreaterAddr() string {
	if m != nil {
		return m.CreaterAddr
	}
	return ""
}

func (m *ReceiptRelayLog) GetCoinOperation() string {
	if m != nil {
		return m.CoinOperation
	}
	return ""
}

func (m *ReceiptRelayLog) GetCoin() string {
	if m != nil {
		return m.Coin
	}
	return ""
}

func (m *ReceiptRelayLog) GetCoinAmount() string {
	if m != nil {
		return m.CoinAmount
	}
	return ""
}

func (m *ReceiptRelayLog) GetCoinAddr() string {
	if m != nil {
		return m.CoinAddr
	}
	return ""
}

func (m *ReceiptRelayLog) GetCoinTxHash() string {
	if m != nil {
		return m.CoinTxHash
	}
	return ""
}

func (m *ReceiptRelayLog) GetCreateTime() int64 {
	if m != nil {
		return m.CreateTime
	}
	return 0
}

func (m *ReceiptRelayLog) GetAcceptAddr() string {
	if m != nil {
		return m.AcceptAddr
	}
	return ""
}

func (m *ReceiptRelayLog) GetAcceptTime() int64 {
	if m != nil {
		return m.AcceptTime
	}
	return 0
}

func (m *ReceiptRelayLog) GetConfirmTime() int64 {
	if m != nil {
		return m.ConfirmTime
	}
	return 0
}

func (m *ReceiptRelayLog) GetFinishTime() int64 {
	if m != nil {
		return m.FinishTime
	}
	return 0
}

func (m *ReceiptRelayLog) GetFinishTxHash() string {
	if m != nil {
		return m.FinishTxHash
	}
	return ""
}

func (m *ReceiptRelayLog) GetCoinHeight() uint64 {
	if m != nil {
		return m.CoinHeight
	}
	return 0
}

func (m *ReceiptRelayLog) GetCoinWaits() uint32 {
	if m != nil {
		return m.CoinWaits
	}
	return 0
}

type ReqRelayAddrCoins struct {
	Addr                 string           `protobuf:"bytes,1,opt,name=addr,proto3" json:"addr,omitempty"`
	Status               RelayOrderStatus `protobuf:"varint,2,opt,name=status,proto3,enum=types.RelayOrderStatus" json:"status,omitempty"`
	Coins                []string         `protobuf:"bytes,3,rep,name=coins,proto3" json:"coins,omitempty"`
	PageNumber           int32            `protobuf:"varint,4,opt,name=pageNumber,proto3" json:"pageNumber,omitempty"`
	PageSize             int32            `protobuf:"varint,5,opt,name=pageSize,proto3" json:"pageSize,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

func (m *ReqRelayAddrCoins) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReqRelayAddrCoins.Unmarshal(m, b)
}
func (m *ReqRelayAddrCoins) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReqRelayAddrCoins.Marshal(b, m, deterministic)
}
func (m *ReqRelayAddrCoins) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReqRelayAddrCoins.Merge(m, src)
}
func (m *ReqRelayAddrCoins) XXX_Size() int {
	return xxx_messageInfo_ReqRelayAddrCoins.Size(m)
}
func (m *ReqRelayAddrCoins) XXX_DiscardUnknown() {
	xxx_messageInfo_ReqRelayAddrCoins.DiscardUnknown(m)
}

var xxx_messageInfo_ReqRelayAddrCoins proto.InternalMessageInfo

func (m *ReqRelayAddrCoins) GetAddr() string {
	if m != nil {
		return m.Addr
	}
	return ""
}

func (m *ReqRelayAddrCoins) GetStatus() RelayOrderStatus {
	if m != nil {
		return m.Status
	}
	return RelayOrderStatus_init
}

func (m *ReqRelayAddrCoins) GetCoins() []string {
	if m != nil {
		return m.Coins
	}
	return nil
}

func (m *ReqRelayAddrCoins) GetPageNumber() int32 {
	if m != nil {
		return m.PageNumber
	}
	return 0
}

func (m *ReqRelayAddrCoins) GetPageSize() int32 {
	if m != nil {
		return m.PageSize
	}
	return 0
}

type ReplyRelayOrders struct {
	Relayorders          []*RelayOrder `protobuf:"bytes,1,rep,name=relayorders,proto3" json:"relayorders,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

func (m *ReplyRelayOrders) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReplyRelayOrders.Unmarshal(m, b)
}
func (m *ReplyRelayOrders) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReplyRelayOrders.Marshal(b, m, deterministic)
}
func (m *ReplyRelayOrders) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReplyRelayOrders.Merge(m, src)
}
func (m *ReplyRelayOrders) XXX_Size() int {
	return xxx_messageInfo_ReplyRelayOrders.Size(m)
}
func (m *ReplyRelayOrders) XXX_DiscardUnknown() {
	xxx_messageInfo_ReplyRelayOrders.DiscardUnknown(m)
}

var xxx_messageInfo_ReplyRelayOrders proto.InternalMessageInfo

func (m *ReplyRelayOrders) GetRelayorders() []*RelayOrder {
	if m != nil {
		return m.Relayorders
	}
	return nil
}

type QueryRelayOrderParam struct {
	Status               RelayOrderStatus `protobuf:"varint,1,opt,name=status,proto3,enum=types.RelayOrderStatus" json:"status,omitempty"`
	OrderId              string           `protobuf:"bytes,2,opt,name=orderId,proto3" json:"orderId,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

func (m *QueryRelayOrderParam) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_QueryRelayOrderParam.Unmarshal(m, b)
}
func (m *QueryRelayOrderParam) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_QueryRelayOrderParam.Marshal(b, m, deterministic)
}
func (m *QueryRelayOrderParam) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryRelayOrderParam.Merge(m, src)
}
func (m *QueryRelayOrderParam) XXX_Size() int {
	return xxx_messageInfo_QueryRelayOrderParam.Size(m)
}
func (m *QueryRelayOrderParam) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryRelayOrderParam.DiscardUnknown(m)
}

var xxx_messageInfo_QueryRelayOrderParam proto.InternalMessageInfo

func (m *QueryRelayOrderParam) GetStatus() RelayOrderStatus {
	if m != nil {
		return m.Status
	}
	return RelayOrderStatus_init
}

func (m *QueryRelayOrderParam) GetOrderId() string {
	if m != nil {
		return m.OrderId
	}
	return ""
}

type QueryRelayOrderResult struct {
	Orders               []*RelayOrder `protobuf:"bytes,1,rep,name=orders,proto3" json:"orders,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

func (m *QueryRelayOrderResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_QueryRelayOrderResult.Unmarshal(m, b)
}
func (m *QueryRelayOrderResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_QueryRelayOrderResult.Marshal(b, m, deterministic)
}
func (m *QueryRelayOrderResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryRelayOrderResult.Merge(m, src)
}
func (m *QueryRelayOrderResult) XXX_Size() int {
	return xxx_messageInfo_QueryRelayOrderResult.Size(m)
}
func (m *QueryRelayOrderResult) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryRelayOrderResult.DiscardUnknown(m)
}

var xxx_messageInfo_QueryRelayOrderResult proto.InternalMessageInfo

func (m *QueryRelayOrderResult) GetOrders() []*RelayOrder {
	if m != nil {
		return m.Orders
	}
	return nil
}

type ReqRelayBtcHeaderHeightList struct {
	ReqHeight            int64    `protobuf:"varint,1,opt,name=reqHeight,proto3" json:"reqHeight,omitempty"`
	Counts               int32    `protobuf:"varint,2,opt,name=counts,proto3" json:"counts,omitempty"`
	Direction            int32    `protobuf:"varint,3,opt,name=direction,proto3" json:"direction,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *ReqRelayBtcHeaderHeightList) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReqRelayBtcHeaderHeightList.Unmarshal(m, b)
}
func (m *ReqRelayBtcHeaderHeightList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReqRelayBtcHeaderHeightList.Marshal(b, m, deterministic)
}
func (m *ReqRelayBtcHeaderHeightList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReqRelayBtcHeaderHeightList.Merge(m, src)
}
func (m *ReqRelayBtcHeaderHeightList) XXX_Size() int {
	return xxx_messageInfo_ReqRelayBtcHeaderHeightList.Size(m)
}
func (m *ReqRelayBtcHeaderHeightList) XXX_DiscardUnknown() {
	xxx_messageInfo_ReqRelayBtcHeaderHeightList.DiscardUnknown(m)
}

var xxx_messageInfo_ReqRelayBtcHeaderHeightList proto.InternalMessageInfo

func (m *ReqRelayBtcHeaderHeightList) GetReqHeight() int64 {
	if m != nil {
		return m.ReqHeight
	}
	return 0
}

func (m *ReqRelayBtcHeaderHeightList) GetCounts() int32 {
	if m != nil {
		return m.Counts
	}
	return 0
}

func (m *ReqRelayBtcHeaderHeightList) GetDirection() int32 {
	if m != nil {
		return m.Direction
	}
	return 0
}

type ReplyRelayBtcHeadHeightList struct {
	Heights              []int64  `protobuf:"varint,1,rep,packed,name=heights,proto3" json:"heights,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ReplyRelayBtcHeadHeightList) Reset()         { *m = ReplyRelayBtcHeadHeightList{} }
func (m *ReplyRelayBtcHeadHeightList) String() string { return proto.CompactTextString(m) }
func (*ReplyRelayBtcHeadHeightList) ProtoMessage()    {}
func (*ReplyRelayBtcHeadHeightList) Descriptor() ([]byte, []int) {
	return fileDescriptor_9f69a7d5a802d584, []int{22}
}

func (m *ReplyRelayBtcHeadHeightList) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReplyRelayBtcHeadHeightList.Unmarshal(m, b)
}
func (m *ReplyRelayBtcHeadHeightList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReplyRelayBtcHeadHeightList.Marshal(b, m, deterministic)
}
func (m *ReplyRelayBtcHeadHeightList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReplyRelayBtcHeadHeightList.Merge(m, src)
}
func (m *ReplyRelayBtcHeadHeightList) XXX_Size() int {
	return xxx_messageInfo_ReplyRelayBtcHeadHeightList.Size(m)
}
func (m *ReplyRelayBtcHeadHeightList) XXX_DiscardUnknown() {
	xxx_messageInfo_ReplyRelayBtcHeadHeightList.DiscardUnknown(m)
}

var xxx_messageInfo_ReplyRelayBtcHeadHeightList proto.InternalMessageInfo

func (m *ReplyRelayBtcHeadHeightList) GetHeights() []int64 {
	if m != nil {
		return m.Heights
	}
	return nil
}

type ReqRelayQryBTCHeadHeight struct {
	BaseHeight           int64    `protobuf:"varint,1,opt,name=baseHeight,proto3" json:"baseHeight,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ReqRelayQryBTCHeadHeight) Reset()         { *m = ReqRelayQryBTCHeadHeight{} }
func (m *ReqRelayQryBTCHeadHeight) String() string { return proto.CompactTextString(m) }
func (*ReqRelayQryBTCHeadHeight) ProtoMessage()    {}
func (*ReqRelayQryBTCHeadHeight) Descriptor() ([]byte, []int) {
	return fileDescriptor_9f69a7d5a802d584, []int{23}
}

func (m *ReqRelayQryBTCHeadHeight) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReqRelayQryBTCHeadHeight.Unmarshal(m, b)
}
func (m *ReqRelayQryBTCHeadHeight) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReqRelayQryBTCHeadHeight.Marshal(b, m, deterministic)
}
func (m *ReqRelayQryBTCHeadHeight) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReqRelayQryBTCHeadHeight.Merge(m, src)
}
func (m *ReqRelayQryBTCHeadHeight) XXX_Size() int {
	return xxx_messageInfo_ReqRelayQryBTCHeadHeight.Size(m)
}
func (m *ReqRelayQryBTCHeadHeight) XXX_DiscardUnknown() {
	xxx_messageInfo_ReqRelayQryBTCHeadHeight.DiscardUnknown(m)
}

var xxx_messageInfo_ReqRelayQryBTCHeadHeight proto.InternalMessageInfo

func (m *ReqRelayQryBTCHeadHeight) GetBaseHeight() int64 {
	if m != nil {
		return m.BaseHeight
	}
	return 0
}

type ReplayRelayQryBTCHeadHeight struct {
	CurHeight            int64    `protobuf:"varint,1,opt,name=curHeight,proto3" json:"curHeight,omitempty"`
	BaseHeight           int64    `protobuf:"varint,2,opt,name=baseHeight,proto3" json:"baseHeight,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ReplayRelayQryBTCHeadHeight) Reset()         { *m = ReplayRelayQryBTCHeadHeight{} }
func (m *ReplayRelayQryBTCHeadHeight) String() string { return proto.CompactTextString(m) }
func (*ReplayRelayQryBTCHeadHeight) ProtoMessage()    {}
func (*ReplayRelayQryBTCHeadHeight) Descriptor() ([]byte, []int) {
	return fileDescriptor_9f69a7d5a802d584, []int{24}
}

func (m *ReplayRelayQryBTCHeadHeight) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReplayRelayQryBTCHeadHeight.Unmarshal(m, b)
}
func (m *ReplayRelayQryBTCHeadHeight) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReplayRelayQryBTCHeadHeight.Marshal(b, m, deterministic)
}
func (m *ReplayRelayQryBTCHeadHeight) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReplayRelayQryBTCHeadHeight.Merge(m, src)
}
func (m *ReplayRelayQryBTCHeadHeight) XXX_Size() int {
	return xxx_messageInfo_ReplayRelayQryBTCHeadHeight.Size(m)
}
func (m *ReplayRelayQryBTCHeadHeight) XXX_DiscardUnknown() {
	xxx_messageInfo_ReplayRelayQryBTCHeadHeight.DiscardUnknown(m)
}

var xxx_messageInfo_ReplayRelayQryBTCHeadHeight proto.InternalMessageInfo

func (m *ReplayRelayQryBTCHeadHeight) GetCurHeight() int64 {
	if m != nil {
		return m.CurHeight
	}
	return 0
}

func (m *ReplayRelayQryBTCHeadHeight) GetBaseHeight() int64 {
	if m != nil {
		return m.BaseHeight
	}
	return 0
}

func init() {
	proto.RegisterEnum("types.RelayOrderStatus", RelayOrderStatus_name, RelayOrderStatus_value)
	proto.RegisterType((*RelayAction)(nil), "types.RelayAction")
	proto.RegisterType((*RelayOrder)(nil), "types.RelayOrder")
	proto.RegisterType((*RelayCreate)(nil), "types.RelayCreate")
	proto.RegisterType((*RelayAccept)(nil), "types.RelayAccept")
	proto.RegisterType((*RelayRevoke)(nil), "types.RelayRevoke")
	proto.RegisterType((*RelayConfirmTx)(nil), "types.RelayConfirmTx")
	proto.RegisterType((*RelayVerify)(nil), "types.RelayVerify")
	proto.RegisterType((*RelayVerifyCli)(nil), "types.RelayVerifyCli")
	proto.RegisterType((*BtcHeader)(nil), "types.BtcHeader")
	proto.RegisterType((*BtcHeaders)(nil), "types.BtcHeaders")
	proto.RegisterType((*BtcTransaction)(nil), "types.BtcTransaction")
	proto.RegisterType((*Vin)(nil), "types.Vin")
	proto.RegisterType((*Vout)(nil), "types.Vout")
	proto.RegisterType((*BtcSpv)(nil), "types.BtcSpv")
	proto.RegisterType((*RelayLastRcvBtcHeader)(nil), "types.RelayLastRcvBtcHeader")
	proto.RegisterType((*ReceiptRelayRcvBTCHeaders)(nil), "types.ReceiptRelayRcvBTCHeaders")
	proto.RegisterType((*ReceiptRelayLog)(nil), "types.ReceiptRelayLog")
	proto.RegisterType((*ReqRelayAddrCoins)(nil), "types.ReqRelayAddrCoins")
	proto.RegisterType((*ReplyRelayOrders)(nil), "types.ReplyRelayOrders")
	proto.RegisterType((*QueryRelayOrderParam)(nil), "types.QueryRelayOrderParam")
	proto.RegisterType((*QueryRelayOrderResult)(nil), "types.QueryRelayOrderResult")
	proto.RegisterType((*ReqRelayBtcHeaderHeightList)(nil), "types.ReqRelayBtcHeaderHeightList")
	proto.RegisterType((*ReplyRelayBtcHeadHeightList)(nil), "types.ReplyRelayBtcHeadHeightList")
	proto.RegisterType((*ReqRelayQryBTCHeadHeight)(nil), "types.ReqRelayQryBTCHeadHeight")
	proto.RegisterType((*ReplayRelayQryBTCHeadHeight)(nil), "types.ReplayRelayQryBTCHeadHeight")
}

func init() { proto.RegisterFile("relay.proto", fileDescriptor_9f69a7d5a802d584) }

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