nodemessage.pb.go

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

package pb

import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/gogo/protobuf/gogoproto"

import strconv "strconv"

import bytes "bytes"

import strings "strings"
import reflect "reflect"

import io "io"

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

type MessageType int32

const (
	MESSAGE_TYPE_PLACEHOLDER_DO_NOT_USE       MessageType = 0
	VOTE                                      MessageType = 1
	I_HAVE_BLOCK_PROPOSAL                     MessageType = 2
	REQUEST_BLOCK_PROPOSAL                    MessageType = 3
	REQUEST_BLOCK_PROPOSAL_REPLY              MessageType = 4
	GET_CONSENSUS_STATE                       MessageType = 5
	GET_CONSENSUS_STATE_REPLY                 MessageType = 6
	GET_BLOCK_HEADERS                         MessageType = 7
	GET_BLOCK_HEADERS_REPLY                   MessageType = 8
	GET_BLOCKS                                MessageType = 9
	GET_BLOCKS_REPLY                          MessageType = 10
	RELAY                                     MessageType = 11
	TRANSACTIONS                              MessageType = 12
	BACKTRACK_SIGNATURE_CHAIN                 MessageType = 13
	REQUEST_PROPOSAL_TRANSACTIONS             MessageType = 14
	REQUEST_PROPOSAL_TRANSACTIONS_REPLY       MessageType = 15
	I_HAVE_SIGNATURE_CHAIN_TRANSACTION        MessageType = 16
	REQUEST_SIGNATURE_CHAIN_TRANSACTION       MessageType = 17
	REQUEST_SIGNATURE_CHAIN_TRANSACTION_REPLY MessageType = 18
)

var MessageType_name = map[int32]string{
	0:  "MESSAGE_TYPE_PLACEHOLDER_DO_NOT_USE",
	1:  "VOTE",
	2:  "I_HAVE_BLOCK_PROPOSAL",
	3:  "REQUEST_BLOCK_PROPOSAL",
	4:  "REQUEST_BLOCK_PROPOSAL_REPLY",
	5:  "GET_CONSENSUS_STATE",
	6:  "GET_CONSENSUS_STATE_REPLY",
	7:  "GET_BLOCK_HEADERS",
	8:  "GET_BLOCK_HEADERS_REPLY",
	9:  "GET_BLOCKS",
	10: "GET_BLOCKS_REPLY",
	11: "RELAY",
	12: "TRANSACTIONS",
	13: "BACKTRACK_SIGNATURE_CHAIN",
	14: "REQUEST_PROPOSAL_TRANSACTIONS",
	15: "REQUEST_PROPOSAL_TRANSACTIONS_REPLY",
	16: "I_HAVE_SIGNATURE_CHAIN_TRANSACTION",
	17: "REQUEST_SIGNATURE_CHAIN_TRANSACTION",
	18: "REQUEST_SIGNATURE_CHAIN_TRANSACTION_REPLY",
}
var MessageType_value = map[string]int32{
	"MESSAGE_TYPE_PLACEHOLDER_DO_NOT_USE": 0,
	"VOTE":                                      1,
	"I_HAVE_BLOCK_PROPOSAL":                     2,
	"REQUEST_BLOCK_PROPOSAL":                    3,
	"REQUEST_BLOCK_PROPOSAL_REPLY":              4,
	"GET_CONSENSUS_STATE":                       5,
	"GET_CONSENSUS_STATE_REPLY":                 6,
	"GET_BLOCK_HEADERS":                         7,
	"GET_BLOCK_HEADERS_REPLY":                   8,
	"GET_BLOCKS":                                9,
	"GET_BLOCKS_REPLY":                          10,
	"RELAY":                                     11,
	"TRANSACTIONS":                              12,
	"BACKTRACK_SIGNATURE_CHAIN":                 13,
	"REQUEST_PROPOSAL_TRANSACTIONS":             14,
	"REQUEST_PROPOSAL_TRANSACTIONS_REPLY":       15,
	"I_HAVE_SIGNATURE_CHAIN_TRANSACTION":        16,
	"REQUEST_SIGNATURE_CHAIN_TRANSACTION":       17,
	"REQUEST_SIGNATURE_CHAIN_TRANSACTION_REPLY": 18,
}

func (MessageType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_nodemessage_c02ceb21668725d0, []int{0}
}

// Message type that can be signed message
// Name doesn't matter, but value nees to match the value in MessageType
type AllowedSignedMessageType int32

const (
	ALLOW_SIGNED_PLACEHOLDER_DO_NOT_USE AllowedSignedMessageType = 0
)

var AllowedSignedMessageType_name = map[int32]string{
	0: "ALLOW_SIGNED_PLACEHOLDER_DO_NOT_USE",
}
var AllowedSignedMessageType_value = map[string]int32{
	"ALLOW_SIGNED_PLACEHOLDER_DO_NOT_USE": 0,
}

func (AllowedSignedMessageType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_nodemessage_c02ceb21668725d0, []int{1}
}

// Message type that can be unsigned message
// Name doesn't matter, but value nees to match the value in MessageType
type AllowedUnsignedMessageType int32

const (
	ALLOW_UNSIGNED_PLACEHOLDER_DO_NOT_USE                    AllowedUnsignedMessageType = 0
	ALLOW_UNSIGNED_VOTE                                      AllowedUnsignedMessageType = 1
	ALLOW_UNSIGNED_I_HAVE_BLOCK_PROPOSAL                     AllowedUnsignedMessageType = 2
	ALLOW_UNSIGNED_REQUEST_BLOCK_PROPOSAL                    AllowedUnsignedMessageType = 3
	ALLOW_UNSIGNED_REQUEST_BLOCK_REPLY                       AllowedUnsignedMessageType = 4
	ALLOW_UNSIGNED_GET_CONSENSUS_STATE                       AllowedUnsignedMessageType = 5
	ALLOW_UNSIGNED_GET_CONSENSUS_STATE_REPLY                 AllowedUnsignedMessageType = 6
	ALLOW_UNSIGNED_GET_BLOCK_HEADERS                         AllowedUnsignedMessageType = 7
	ALLOW_UNSIGNED_GET_BLOCK_HEADERS_REPLY                   AllowedUnsignedMessageType = 8
	ALLOW_UNSIGNED_GET_BLOCKS                                AllowedUnsignedMessageType = 9
	ALLOW_UNSIGNED_GET_BLOCKS_REPLY                          AllowedUnsignedMessageType = 10
	ALLOW_UNSIGNED_RELAY                                     AllowedUnsignedMessageType = 11
	ALLOW_UNSIGNED_TRANSACTIONS                              AllowedUnsignedMessageType = 12
	ALLOW_UNSIGNED_BACKTRACK_SIGNATURE_CHAIN                 AllowedUnsignedMessageType = 13
	ALLOW_UNSIGNED_REQUEST_PROPOSAL_TRANSACTIONS             AllowedUnsignedMessageType = 14
	ALLOW_UNSIGNED_REQUEST_PROPOSAL_TRANSACTIONS_REPLY       AllowedUnsignedMessageType = 15
	ALLOW_UNSIGNED_I_HAVE_SIGNATURE_CHAIN_TRANSACTION        AllowedUnsignedMessageType = 16
	ALLOW_UNSIGNED_REQUEST_SIGNATURE_CHAIN_TRANSACTION       AllowedUnsignedMessageType = 17
	ALLOW_UNSIGNED_REQUEST_SIGNATURE_CHAIN_TRANSACTION_REPLY AllowedUnsignedMessageType = 18
)

var AllowedUnsignedMessageType_name = map[int32]string{
	0:  "ALLOW_UNSIGNED_PLACEHOLDER_DO_NOT_USE",
	1:  "ALLOW_UNSIGNED_VOTE",
	2:  "ALLOW_UNSIGNED_I_HAVE_BLOCK_PROPOSAL",
	3:  "ALLOW_UNSIGNED_REQUEST_BLOCK_PROPOSAL",
	4:  "ALLOW_UNSIGNED_REQUEST_BLOCK_REPLY",
	5:  "ALLOW_UNSIGNED_GET_CONSENSUS_STATE",
	6:  "ALLOW_UNSIGNED_GET_CONSENSUS_STATE_REPLY",
	7:  "ALLOW_UNSIGNED_GET_BLOCK_HEADERS",
	8:  "ALLOW_UNSIGNED_GET_BLOCK_HEADERS_REPLY",
	9:  "ALLOW_UNSIGNED_GET_BLOCKS",
	10: "ALLOW_UNSIGNED_GET_BLOCKS_REPLY",
	11: "ALLOW_UNSIGNED_RELAY",
	12: "ALLOW_UNSIGNED_TRANSACTIONS",
	13: "ALLOW_UNSIGNED_BACKTRACK_SIGNATURE_CHAIN",
	14: "ALLOW_UNSIGNED_REQUEST_PROPOSAL_TRANSACTIONS",
	15: "ALLOW_UNSIGNED_REQUEST_PROPOSAL_TRANSACTIONS_REPLY",
	16: "ALLOW_UNSIGNED_I_HAVE_SIGNATURE_CHAIN_TRANSACTION",
	17: "ALLOW_UNSIGNED_REQUEST_SIGNATURE_CHAIN_TRANSACTION",
	18: "ALLOW_UNSIGNED_REQUEST_SIGNATURE_CHAIN_TRANSACTION_REPLY",
}
var AllowedUnsignedMessageType_value = map[string]int32{
	"ALLOW_UNSIGNED_PLACEHOLDER_DO_NOT_USE":                    0,
	"ALLOW_UNSIGNED_VOTE":                                      1,
	"ALLOW_UNSIGNED_I_HAVE_BLOCK_PROPOSAL":                     2,
	"ALLOW_UNSIGNED_REQUEST_BLOCK_PROPOSAL":                    3,
	"ALLOW_UNSIGNED_REQUEST_BLOCK_REPLY":                       4,
	"ALLOW_UNSIGNED_GET_CONSENSUS_STATE":                       5,
	"ALLOW_UNSIGNED_GET_CONSENSUS_STATE_REPLY":                 6,
	"ALLOW_UNSIGNED_GET_BLOCK_HEADERS":                         7,
	"ALLOW_UNSIGNED_GET_BLOCK_HEADERS_REPLY":                   8,
	"ALLOW_UNSIGNED_GET_BLOCKS":                                9,
	"ALLOW_UNSIGNED_GET_BLOCKS_REPLY":                          10,
	"ALLOW_UNSIGNED_RELAY":                                     11,
	"ALLOW_UNSIGNED_TRANSACTIONS":                              12,
	"ALLOW_UNSIGNED_BACKTRACK_SIGNATURE_CHAIN":                 13,
	"ALLOW_UNSIGNED_REQUEST_PROPOSAL_TRANSACTIONS":             14,
	"ALLOW_UNSIGNED_REQUEST_PROPOSAL_TRANSACTIONS_REPLY":       15,
	"ALLOW_UNSIGNED_I_HAVE_SIGNATURE_CHAIN_TRANSACTION":        16,
	"ALLOW_UNSIGNED_REQUEST_SIGNATURE_CHAIN_TRANSACTION":       17,
	"ALLOW_UNSIGNED_REQUEST_SIGNATURE_CHAIN_TRANSACTION_REPLY": 18,
}

func (AllowedUnsignedMessageType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_nodemessage_c02ceb21668725d0, []int{2}
}

// Message type that can be sent as direct message
// Name doesn't matter, but value nees to match the value in MessageType
type AllowedDirectMessageType int32

const (
	ALLOW_DIRECT_PLACEHOLDER_DO_NOT_USE                    AllowedDirectMessageType = 0
	ALLOW_DIRECT_VOTE                                      AllowedDirectMessageType = 1
	ALLOW_DIRECT_I_HAVE_BLOCK_PROPOSAL                     AllowedDirectMessageType = 2
	ALLOW_DIRECT_REQUEST_BLOCK_PROPOSAL                    AllowedDirectMessageType = 3
	ALLOW_DIRECT_REQUEST_BLOCK_REPLY                       AllowedDirectMessageType = 4
	ALLOW_DIRECT_GET_CONSENSUS_STATE                       AllowedDirectMessageType = 5
	ALLOW_DIRECT_GET_CONSENSUS_STATE_REPLY                 AllowedDirectMessageType = 6
	ALLOW_DIRECT_GET_BLOCK_HEADERS                         AllowedDirectMessageType = 7
	ALLOW_DIRECT_GET_BLOCK_HEADERS_REPLY                   AllowedDirectMessageType = 8
	ALLOW_DIRECT_GET_BLOCKS                                AllowedDirectMessageType = 9
	ALLOW_DIRECT_GET_BLOCKS_REPLY                          AllowedDirectMessageType = 10
	ALLOW_DIRECT_BACKTRACK_SIGNATURE_CHAIN                 AllowedDirectMessageType = 13
	ALLOW_DIRECT_REQUEST_PROPOSAL_TRANSACTIONS             AllowedDirectMessageType = 14
	ALLOW_DIRECT_REQUEST_PROPOSAL_TRANSACTIONS_REPLY       AllowedDirectMessageType = 15
	ALLOW_DIRECT_I_HAVE_SIGNATURE_CHAIN_TRANSACTION        AllowedDirectMessageType = 16
	ALLOW_DIRECT_REQUEST_SIGNATURE_CHAIN_TRANSACTION       AllowedDirectMessageType = 17
	ALLOW_DIRECT_REQUEST_SIGNATURE_CHAIN_TRANSACTION_REPLY AllowedDirectMessageType = 18
)

var AllowedDirectMessageType_name = map[int32]string{
	0:  "ALLOW_DIRECT_PLACEHOLDER_DO_NOT_USE",
	1:  "ALLOW_DIRECT_VOTE",
	2:  "ALLOW_DIRECT_I_HAVE_BLOCK_PROPOSAL",
	3:  "ALLOW_DIRECT_REQUEST_BLOCK_PROPOSAL",
	4:  "ALLOW_DIRECT_REQUEST_BLOCK_REPLY",
	5:  "ALLOW_DIRECT_GET_CONSENSUS_STATE",
	6:  "ALLOW_DIRECT_GET_CONSENSUS_STATE_REPLY",
	7:  "ALLOW_DIRECT_GET_BLOCK_HEADERS",
	8:  "ALLOW_DIRECT_GET_BLOCK_HEADERS_REPLY",
	9:  "ALLOW_DIRECT_GET_BLOCKS",
	10: "ALLOW_DIRECT_GET_BLOCKS_REPLY",
	13: "ALLOW_DIRECT_BACKTRACK_SIGNATURE_CHAIN",
	14: "ALLOW_DIRECT_REQUEST_PROPOSAL_TRANSACTIONS",
	15: "ALLOW_DIRECT_REQUEST_PROPOSAL_TRANSACTIONS_REPLY",
	16: "ALLOW_DIRECT_I_HAVE_SIGNATURE_CHAIN_TRANSACTION",
	17: "ALLOW_DIRECT_REQUEST_SIGNATURE_CHAIN_TRANSACTION",
	18: "ALLOW_DIRECT_REQUEST_SIGNATURE_CHAIN_TRANSACTION_REPLY",
}
var AllowedDirectMessageType_value = map[string]int32{
	"ALLOW_DIRECT_PLACEHOLDER_DO_NOT_USE":                    0,
	"ALLOW_DIRECT_VOTE":                                      1,
	"ALLOW_DIRECT_I_HAVE_BLOCK_PROPOSAL":                     2,
	"ALLOW_DIRECT_REQUEST_BLOCK_PROPOSAL":                    3,
	"ALLOW_DIRECT_REQUEST_BLOCK_REPLY":                       4,
	"ALLOW_DIRECT_GET_CONSENSUS_STATE":                       5,
	"ALLOW_DIRECT_GET_CONSENSUS_STATE_REPLY":                 6,
	"ALLOW_DIRECT_GET_BLOCK_HEADERS":                         7,
	"ALLOW_DIRECT_GET_BLOCK_HEADERS_REPLY":                   8,
	"ALLOW_DIRECT_GET_BLOCKS":                                9,
	"ALLOW_DIRECT_GET_BLOCKS_REPLY":                          10,
	"ALLOW_DIRECT_BACKTRACK_SIGNATURE_CHAIN":                 13,
	"ALLOW_DIRECT_REQUEST_PROPOSAL_TRANSACTIONS":             14,
	"ALLOW_DIRECT_REQUEST_PROPOSAL_TRANSACTIONS_REPLY":       15,
	"ALLOW_DIRECT_I_HAVE_SIGNATURE_CHAIN_TRANSACTION":        16,
	"ALLOW_DIRECT_REQUEST_SIGNATURE_CHAIN_TRANSACTION":       17,
	"ALLOW_DIRECT_REQUEST_SIGNATURE_CHAIN_TRANSACTION_REPLY": 18,
}

func (AllowedDirectMessageType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_nodemessage_c02ceb21668725d0, []int{3}
}

// Message type that can be sent as relay message
// Name doesn't matter, but value nees to match the value in MessageType
type AllowedRelayMessageType int32

const (
	ALLOW_RELAY_PLACEHOLDER_DO_NOT_USE AllowedRelayMessageType = 0
	ALLOW_RELAY_RELAY                  AllowedRelayMessageType = 11
)

var AllowedRelayMessageType_name = map[int32]string{
	0:  "ALLOW_RELAY_PLACEHOLDER_DO_NOT_USE",
	11: "ALLOW_RELAY_RELAY",
}
var AllowedRelayMessageType_value = map[string]int32{
	"ALLOW_RELAY_PLACEHOLDER_DO_NOT_USE": 0,
	"ALLOW_RELAY_RELAY":                  11,
}

func (AllowedRelayMessageType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_nodemessage_c02ceb21668725d0, []int{4}
}

// Message type that can be sent as broadcast_push message
// Name doesn't matter, but value nees to match the value in MessageType
type AllowedBroadcastPushMessageType int32

const (
	ALLOW_BROADCAST_PUSH_PLACEHOLDER_DO_NOT_USE AllowedBroadcastPushMessageType = 0
	ALLOW_BROADCAST_PUSH_TRANSACTIONS           AllowedBroadcastPushMessageType = 12
)

var AllowedBroadcastPushMessageType_name = map[int32]string{
	0:  "ALLOW_BROADCAST_PUSH_PLACEHOLDER_DO_NOT_USE",
	12: "ALLOW_BROADCAST_PUSH_TRANSACTIONS",
}
var AllowedBroadcastPushMessageType_value = map[string]int32{
	"ALLOW_BROADCAST_PUSH_PLACEHOLDER_DO_NOT_USE": 0,
	"ALLOW_BROADCAST_PUSH_TRANSACTIONS":           12,
}

func (AllowedBroadcastPushMessageType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_nodemessage_c02ceb21668725d0, []int{5}
}

// Message type that can be sent as broadcast_pull message
// Name doesn't matter, but value nees to match the value in MessageType
type AllowedBroadcastPullMessageType int32

const (
	ALLOW_BROADCAST_PULL_PLACEHOLDER_DO_NOT_USE AllowedBroadcastPullMessageType = 0
)

var AllowedBroadcastPullMessageType_name = map[int32]string{
	0: "ALLOW_BROADCAST_PULL_PLACEHOLDER_DO_NOT_USE",
}
var AllowedBroadcastPullMessageType_value = map[string]int32{
	"ALLOW_BROADCAST_PULL_PLACEHOLDER_DO_NOT_USE": 0,
}

func (AllowedBroadcastPullMessageType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_nodemessage_c02ceb21668725d0, []int{6}
}

// Message type that can be sent as broadcast_tree message
// Name doesn't matter, but value nees to match the value in MessageType
type AllowedBroadcastTreeMessageType int32

const (
	ALLOW_BROADCAST_TREE_PLACEHOLDER_DO_NOT_USE AllowedBroadcastTreeMessageType = 0
	ALLOW_BROADCAST_TREE_TRANSACTIONS           AllowedBroadcastTreeMessageType = 12
)

var AllowedBroadcastTreeMessageType_name = map[int32]string{
	0:  "ALLOW_BROADCAST_TREE_PLACEHOLDER_DO_NOT_USE",
	12: "ALLOW_BROADCAST_TREE_TRANSACTIONS",
}
var AllowedBroadcastTreeMessageType_value = map[string]int32{
	"ALLOW_BROADCAST_TREE_PLACEHOLDER_DO_NOT_USE": 0,
	"ALLOW_BROADCAST_TREE_TRANSACTIONS":           12,
}

func (AllowedBroadcastTreeMessageType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_nodemessage_c02ceb21668725d0, []int{7}
}

type RequestTransactionType int32

const (
	REQUEST_FULL_TRANSACTION       RequestTransactionType = 0
	REQUEST_TRANSACTION_HASH       RequestTransactionType = 1
	REQUEST_TRANSACTION_SHORT_HASH RequestTransactionType = 2
)

var RequestTransactionType_name = map[int32]string{
	0: "REQUEST_FULL_TRANSACTION",
	1: "REQUEST_TRANSACTION_HASH",
	2: "REQUEST_TRANSACTION_SHORT_HASH",
}
var RequestTransactionType_value = map[string]int32{
	"REQUEST_FULL_TRANSACTION":       0,
	"REQUEST_TRANSACTION_HASH":       1,
	"REQUEST_TRANSACTION_SHORT_HASH": 2,
}

func (RequestTransactionType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_nodemessage_c02ceb21668725d0, []int{8}
}

type UnsignedMessage struct {
	MessageType MessageType `protobuf:"varint,1,opt,name=message_type,json=messageType,proto3,enum=pb.MessageType" json:"message_type,omitempty"`
	Message     []byte      `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
}

func (m *UnsignedMessage) Reset()      { *m = UnsignedMessage{} }
func (*UnsignedMessage) ProtoMessage() {}
func (*UnsignedMessage) Descriptor() ([]byte, []int) {
	return fileDescriptor_nodemessage_c02ceb21668725d0, []int{0}
}
func (m *UnsignedMessage) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UnsignedMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UnsignedMessage.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *UnsignedMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UnsignedMessage.Merge(dst, src)
}
func (m *UnsignedMessage) XXX_Size() int {
	return m.Size()
}
func (m *UnsignedMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_UnsignedMessage.DiscardUnknown(m)
}

var xxx_messageInfo_UnsignedMessage proto.InternalMessageInfo

func (m *UnsignedMessage) GetMessageType() MessageType {
	if m != nil {
		return m.MessageType
	}
	return MESSAGE_TYPE_PLACEHOLDER_DO_NOT_USE
}

func (m *UnsignedMessage) GetMessage() []byte {
	if m != nil {
		return m.Message
	}
	return nil
}

type SignedMessage struct {
	Message   []byte `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
	Signature []byte `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
}

func (m *SignedMessage) Reset()      { *m = SignedMessage{} }
func (*SignedMessage) ProtoMessage() {}
func (*SignedMessage) Descriptor() ([]byte, []int) {
	return fileDescriptor_nodemessage_c02ceb21668725d0, []int{1}
}
func (m *SignedMessage) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SignedMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SignedMessage.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *SignedMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SignedMessage.Merge(dst, src)
}
func (m *SignedMessage) XXX_Size() int {
	return m.Size()
}
func (m *SignedMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_SignedMessage.DiscardUnknown(m)
}

var xxx_messageInfo_SignedMessage proto.InternalMessageInfo

func (m *SignedMessage) GetMessage() []byte {
	if m != nil {
		return m.Message
	}
	return nil
}

func (m *SignedMessage) GetSignature() []byte {
	if m != nil {
		return m.Signature
	}
	return nil
}

type Vote struct {
	Height    uint32 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
	BlockHash []byte `protobuf:"bytes,2,opt,name=block_hash,json=blockHash,proto3" json:"block_hash,omitempty"`
}

func (m *Vote) Reset()      { *m = Vote{} }
func (*Vote) ProtoMessage() {}
func (*Vote) Descriptor() ([]byte, []int) {
	return fileDescriptor_nodemessage_c02ceb21668725d0, []int{2}
}
func (m *Vote) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Vote) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Vote.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *Vote) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Vote.Merge(dst, src)
}
func (m *Vote) XXX_Size() int {
	return m.Size()
}
func (m *Vote) XXX_DiscardUnknown() {
	xxx_messageInfo_Vote.DiscardUnknown(m)
}

var xxx_messageInfo_Vote proto.InternalMessageInfo

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

func (m *Vote) GetBlockHash() []byte {
	if m != nil {
		return m.BlockHash
	}
	return nil
}

type IHaveBlockProposal struct {
	Height    uint32 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
	BlockHash []byte `protobuf:"bytes,2,opt,name=block_hash,json=blockHash,proto3" json:"block_hash,omitempty"`
}

func (m *IHaveBlockProposal) Reset()      { *m = IHaveBlockProposal{} }
func (*IHaveBlockProposal) ProtoMessage() {}
func (*IHaveBlockProposal) Descriptor() ([]byte, []int) {
	return fileDescriptor_nodemessage_c02ceb21668725d0, []int{3}
}
func (m *IHaveBlockProposal) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *IHaveBlockProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_IHaveBlockProposal.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *IHaveBlockProposal) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IHaveBlockProposal.Merge(dst, src)
}
func (m *IHaveBlockProposal) XXX_Size() int {
	return m.Size()
}
func (m *IHaveBlockProposal) XXX_DiscardUnknown() {
	xxx_messageInfo_IHaveBlockProposal.DiscardUnknown(m)
}

var xxx_messageInfo_IHaveBlockProposal proto.InternalMessageInfo

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

func (m *IHaveBlockProposal) GetBlockHash() []byte {
	if m != nil {
		return m.BlockHash
	}
	return nil
}

type RequestBlockProposal struct {
	BlockHash     []byte                 `protobuf:"bytes,1,opt,name=block_hash,json=blockHash,proto3" json:"block_hash,omitempty"`
	Type          RequestTransactionType `protobuf:"varint,2,opt,name=type,proto3,enum=pb.RequestTransactionType" json:"type,omitempty"`
	ShortHashSalt []byte                 `protobuf:"bytes,3,opt,name=short_hash_salt,json=shortHashSalt,proto3" json:"short_hash_salt,omitempty"`
	ShortHashSize uint32                 `protobuf:"varint,4,opt,name=short_hash_size,json=shortHashSize,proto3" json:"short_hash_size,omitempty"`
}

func (m *RequestBlockProposal) Reset()      { *m = RequestBlockProposal{} }
func (*RequestBlockProposal) ProtoMessage() {}
func (*RequestBlockProposal) Descriptor() ([]byte, []int) {
	return fileDescriptor_nodemessage_c02ceb21668725d0, []int{4}
}
func (m *RequestBlockProposal) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RequestBlockProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RequestBlockProposal.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *RequestBlockProposal) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RequestBlockProposal.Merge(dst, src)
}
func (m *RequestBlockProposal) XXX_Size() int {
	return m.Size()
}
func (m *RequestBlockProposal) XXX_DiscardUnknown() {
	xxx_messageInfo_RequestBlockProposal.DiscardUnknown(m)
}

var xxx_messageInfo_RequestBlockProposal proto.InternalMessageInfo

func (m *RequestBlockProposal) GetBlockHash() []byte {
	if m != nil {
		return m.BlockHash
	}
	return nil
}

func (m *RequestBlockProposal) GetType() RequestTransactionType {
	if m != nil {
		return m.Type
	}
	return REQUEST_FULL_TRANSACTION
}

func (m *RequestBlockProposal) GetShortHashSalt() []byte {
	if m != nil {
		return m.ShortHashSalt
	}
	return nil
}

func (m *RequestBlockProposal) GetShortHashSize() uint32 {
	if m != nil {
		return m.ShortHashSize
	}
	return 0
}

type RequestBlockProposalReply struct {
	Block            *Block   `protobuf:"bytes,1,opt,name=block" json:"block,omitempty"`
	TransactionsHash [][]byte `protobuf:"bytes,2,rep,name=transactions_hash,json=transactionsHash" json:"transactions_hash,omitempty"`
}

func (m *RequestBlockProposalReply) Reset()      { *m = RequestBlockProposalReply{} }
func (*RequestBlockProposalReply) ProtoMessage() {}
func (*RequestBlockProposalReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_nodemessage_c02ceb21668725d0, []int{5}
}
func (m *RequestBlockProposalReply) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RequestBlockProposalReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RequestBlockProposalReply.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *RequestBlockProposalReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RequestBlockProposalReply.Merge(dst, src)
}
func (m *RequestBlockProposalReply) XXX_Size() int {
	return m.Size()
}
func (m *RequestBlockProposalReply) XXX_DiscardUnknown() {
	xxx_messageInfo_RequestBlockProposalReply.DiscardUnknown(m)
}

var xxx_messageInfo_RequestBlockProposalReply proto.InternalMessageInfo

func (m *RequestBlockProposalReply) GetBlock() *Block {
	if m != nil {
		return m.Block
	}
	return nil
}

func (m *RequestBlockProposalReply) GetTransactionsHash() [][]byte {
	if m != nil {
		return m.TransactionsHash
	}
	return nil
}

type RequestProposalTransactions struct {
	BlockHash        []byte                 `protobuf:"bytes,1,opt,name=block_hash,json=blockHash,proto3" json:"block_hash,omitempty"`
	Type             RequestTransactionType `protobuf:"varint,2,opt,name=type,proto3,enum=pb.RequestTransactionType" json:"type,omitempty"`
	ShortHashSalt    []byte                 `protobuf:"bytes,3,opt,name=short_hash_salt,json=shortHashSalt,proto3" json:"short_hash_salt,omitempty"`
	ShortHashSize    uint32                 `protobuf:"varint,4,opt,name=short_hash_size,json=shortHashSize,proto3" json:"short_hash_size,omitempty"`
	TransactionsHash [][]byte               `protobuf:"bytes,5,rep,name=transactions_hash,json=transactionsHash" json:"transactions_hash,omitempty"`
}

func (m *RequestProposalTransactions) Reset()      { *m = RequestProposalTransactions{} }
func (*RequestProposalTransactions) ProtoMessage() {}
func (*RequestProposalTransactions) Descriptor() ([]byte, []int) {
	return fileDescriptor_nodemessage_c02ceb21668725d0, []int{6}
}
func (m *RequestProposalTransactions) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RequestProposalTransactions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RequestProposalTransactions.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *RequestProposalTransactions) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RequestProposalTransactions.Merge(dst, src)
}
func (m *RequestProposalTransactions) XXX_Size() int {
	return m.Size()
}
func (m *RequestProposalTransactions) XXX_DiscardUnknown() {
	xxx_messageInfo_RequestProposalTransactions.DiscardUnknown(m)
}

var xxx_messageInfo_RequestProposalTransactions proto.InternalMessageInfo

func (m *RequestProposalTransactions) GetBlockHash() []byte {
	if m != nil {
		return m.BlockHash
	}
	return nil
}

func (m *RequestProposalTransactions) GetType() RequestTransactionType {
	if m != nil {
		return m.Type
	}
	return REQUEST_FULL_TRANSACTION
}

func (m *RequestProposalTransactions) GetShortHashSalt() []byte {
	if m != nil {
		return m.ShortHashSalt
	}
	return nil
}

func (m *RequestProposalTransactions) GetShortHashSize() uint32 {
	if m != nil {
		return m.ShortHashSize
	}
	return 0
}

func (m *RequestProposalTransactions) GetTransactionsHash() [][]byte {
	if m != nil {
		return m.TransactionsHash
	}
	return nil
}

type RequestProposalTransactionsReply struct {
	Transactions []*Transaction `protobuf:"bytes,1,rep,name=transactions" json:"transactions,omitempty"`
}

func (m *RequestProposalTransactionsReply) Reset()      { *m = RequestProposalTransactionsReply{} }
func (*RequestProposalTransactionsReply) ProtoMessage() {}
func (*RequestProposalTransactionsReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_nodemessage_c02ceb21668725d0, []int{7}
}
func (m *RequestProposalTransactionsReply) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RequestProposalTransactionsReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RequestProposalTransactionsReply.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *RequestProposalTransactionsReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RequestProposalTransactionsReply.Merge(dst, src)
}
func (m *RequestProposalTransactionsReply) XXX_Size() int {
	return m.Size()
}
func (m *RequestProposalTransactionsReply) XXX_DiscardUnknown() {
	xxx_messageInfo_RequestProposalTransactionsReply.DiscardUnknown(m)
}

var xxx_messageInfo_RequestProposalTransactionsReply proto.InternalMessageInfo

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

type GetConsensusState struct {
}

func (m *GetConsensusState) Reset()      { *m = GetConsensusState{} }
func (*GetConsensusState) ProtoMessage() {}
func (*GetConsensusState) Descriptor() ([]byte, []int) {
	return fileDescriptor_nodemessage_c02ceb21668725d0, []int{8}
}
func (m *GetConsensusState) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetConsensusState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetConsensusState.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *GetConsensusState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetConsensusState.Merge(dst, src)
}
func (m *GetConsensusState) XXX_Size() int {
	return m.Size()
}
func (m *GetConsensusState) XXX_DiscardUnknown() {
	xxx_messageInfo_GetConsensusState.DiscardUnknown(m)
}

var xxx_messageInfo_GetConsensusState proto.InternalMessageInfo

type GetConsensusStateReply struct {
	LedgerBlockHash     []byte    `protobuf:"bytes,2,opt,name=ledger_block_hash,json=ledgerBlockHash,proto3" json:"ledger_block_hash,omitempty"`
	LedgerHeight        uint32    `protobuf:"varint,1,opt,name=ledger_height,json=ledgerHeight,proto3" json:"ledger_height,omitempty"`
	ConsensusHeight     uint32    `protobuf:"varint,3,opt,name=consensus_height,json=consensusHeight,proto3" json:"consensus_height,omitempty"`
	MinVerifiableHeight uint32    `protobuf:"varint,5,opt,name=min_verifiable_height,json=minVerifiableHeight,proto3" json:"min_verifiable_height,omitempty"`
	SyncState           SyncState `protobuf:"varint,4,opt,name=sync_state,json=syncState,proto3,enum=pb.SyncState" json:"sync_state,omitempty"`
}

func (m *GetConsensusStateReply) Reset()      { *m = GetConsensusStateReply{} }
func (*GetConsensusStateReply) ProtoMessage() {}
func (*GetConsensusStateReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_nodemessage_c02ceb21668725d0, []int{9}
}
func (m *GetConsensusStateReply) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetConsensusStateReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetConsensusStateReply.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *GetConsensusStateReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetConsensusStateReply.Merge(dst, src)
}
func (m *GetConsensusStateReply) XXX_Size() int {
	return m.Size()
}
func (m *GetConsensusStateReply) XXX_DiscardUnknown() {
	xxx_messageInfo_GetConsensusStateReply.DiscardUnknown(m)
}

var xxx_messageInfo_GetConsensusStateReply proto.InternalMessageInfo

func (m *GetConsensusStateReply) GetLedgerBlockHash() []byte {
	if m != nil {
		return m.LedgerBlockHash
	}
	return nil
}

func (m *GetConsensusStateReply) GetLedgerHeight() uint32 {
	if m != nil {
		return m.LedgerHeight
	}
	return 0
}

func (m *GetConsensusStateReply) GetConsensusHeight() uint32 {
	if m != nil {
		return m.ConsensusHeight
	}
	return 0
}

func (m *GetConsensusStateReply) GetMinVerifiableHeight() uint32 {
	if m != nil {
		return m.MinVerifiableHeight
	}
	return 0
}

func (m *GetConsensusStateReply) GetSyncState() SyncState {
	if m != nil {
		return m.SyncState
	}
	return WAIT_FOR_SYNCING
}

type GetBlockHeaders struct {
	StartHeight uint32 `protobuf:"varint,1,opt,name=start_height,json=startHeight,proto3" json:"start_height,omitempty"`
	EndHeight   uint32 `protobuf:"varint,2,opt,name=end_height,json=endHeight,proto3" json:"end_height,omitempty"`
}

func (m *GetBlockHeaders) Reset()      { *m = GetBlockHeaders{} }
func (*GetBlockHeaders) ProtoMessage() {}
func (*GetBlockHeaders) Descriptor() ([]byte, []int) {
	return fileDescriptor_nodemessage_c02ceb21668725d0, []int{10}
}
func (m *GetBlockHeaders) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetBlockHeaders) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetBlockHeaders.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *GetBlockHeaders) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetBlockHeaders.Merge(dst, src)
}
func (m *GetBlockHeaders) XXX_Size() int {
	return m.Size()
}
func (m *GetBlockHeaders) XXX_DiscardUnknown() {
	xxx_messageInfo_GetBlockHeaders.DiscardUnknown(m)
}

var xxx_messageInfo_GetBlockHeaders proto.InternalMessageInfo

func (m *GetBlockHeaders) GetStartHeight() uint32 {
	if m != nil {
		return m.StartHeight
	}
	return 0
}

func (m *GetBlockHeaders) GetEndHeight() uint32 {
	if m != nil {
		return m.EndHeight
	}
	return 0
}

type GetBlockHeadersReply struct {
	BlockHeaders []*Header `protobuf:"bytes,1,rep,name=block_headers,json=blockHeaders" json:"block_headers,omitempty"`
}

func (m *GetBlockHeadersReply) Reset()      { *m = GetBlockHeadersReply{} }
func (*GetBlockHeadersReply) ProtoMessage() {}
func (*GetBlockHeadersReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_nodemessage_c02ceb21668725d0, []int{11}
}
func (m *GetBlockHeadersReply) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetBlockHeadersReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetBlockHeadersReply.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *GetBlockHeadersReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetBlockHeadersReply.Merge(dst, src)
}
func (m *GetBlockHeadersReply) XXX_Size() int {
	return m.Size()
}
func (m *GetBlockHeadersReply) XXX_DiscardUnknown() {
	xxx_messageInfo_GetBlockHeadersReply.DiscardUnknown(m)
}

var xxx_messageInfo_GetBlockHeadersReply proto.InternalMessageInfo

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

type GetBlocks struct {
	StartHeight uint32 `protobuf:"varint,1,opt,name=start_height,json=startHeight,proto3" json:"start_height,omitempty"`
	EndHeight   uint32 `protobuf:"varint,2,opt,name=end_height,json=endHeight,proto3" json:"end_height,omitempty"`
}

func (m *GetBlocks) Reset()      { *m = GetBlocks{} }
func (*GetBlocks) ProtoMessage() {}
func (*GetBlocks) Descriptor() ([]byte, []int) {
	return fileDescriptor_nodemessage_c02ceb21668725d0, []int{12}
}
func (m *GetBlocks) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetBlocks) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetBlocks.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *GetBlocks) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetBlocks.Merge(dst, src)
}
func (m *GetBlocks) XXX_Size() int {
	return m.Size()
}
func (m *GetBlocks) XXX_DiscardUnknown() {
	xxx_messageInfo_GetBlocks.DiscardUnknown(m)
}

var xxx_messageInfo_GetBlocks proto.InternalMessageInfo

func (m *GetBlocks) GetStartHeight() uint32 {
	if m != nil {
		return m.StartHeight
	}
	return 0
}

func (m *GetBlocks) GetEndHeight() uint32 {
	if m != nil {
		return m.EndHeight
	}
	return 0
}

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

func (m *GetBlocksReply) Reset()      { *m = GetBlocksReply{} }
func (*GetBlocksReply) ProtoMessage() {}
func (*GetBlocksReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_nodemessage_c02ceb21668725d0, []int{13}
}
func (m *GetBlocksReply) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetBlocksReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetBlocksReply.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *GetBlocksReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetBlocksReply.Merge(dst, src)
}
func (m *GetBlocksReply) XXX_Size() int {
	return m.Size()
}
func (m *GetBlocksReply) XXX_DiscardUnknown() {
	xxx_messageInfo_GetBlocksReply.DiscardUnknown(m)
}

var xxx_messageInfo_GetBlocksReply proto.InternalMessageInfo

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

type Relay struct {
	SrcIdentifier     string `protobuf:"bytes,1,opt,name=src_identifier,json=srcIdentifier,proto3" json:"src_identifier,omitempty"`
	SrcPubkey         []byte `protobuf:"bytes,6,opt,name=src_pubkey,json=srcPubkey,proto3" json:"src_pubkey,omitempty"`
	DestId            []byte `protobuf:"bytes,2,opt,name=dest_id,json=destId,proto3" json:"dest_id,omitempty"`
	Payload           []byte `protobuf:"bytes,3,opt,name=payload,proto3" json:"payload,omitempty"`
	MaxHoldingSeconds uint32 `protobuf:"varint,5,opt,name=max_holding_seconds,json=maxHoldingSeconds,proto3" json:"max_holding_seconds,omitempty"`
	// It is important to use block hash instead of block height here to allow
	// node in syncing state to be able to sign the sigchain elem.
	BlockHash     []byte `protobuf:"bytes,7,opt,name=block_hash,json=blockHash,proto3" json:"block_hash,omitempty"`
	LastSignature []byte `protobuf:"bytes,8,opt,name=last_signature,json=lastSignature,proto3" json:"last_signature,omitempty"`
	SigChainLen   uint32 `protobuf:"varint,9,opt,name=sig_chain_len,json=sigChainLen,proto3" json:"sig_chain_len,omitempty"`
}

func (m *Relay) Reset()      { *m = Relay{} }
func (*Relay) ProtoMessage() {}
func (*Relay) Descriptor() ([]byte, []int) {
	return fileDescriptor_nodemessage_c02ceb21668725d0, []int{14}
}
func (m *Relay) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Relay) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Relay.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *Relay) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Relay.Merge(dst, src)
}
func (m *Relay) XXX_Size() int {
	return m.Size()
}
func (m *Relay) XXX_DiscardUnknown() {
	xxx_messageInfo_Relay.DiscardUnknown(m)
}

var xxx_messageInfo_Relay proto.InternalMessageInfo

func (m *Relay) GetSrcIdentifier() string {
	if m != nil {
		return m.SrcIdentifier
	}
	return ""
}

func (m *Relay) GetSrcPubkey() []byte {
	if m != nil {
		return m.SrcPubkey
	}
	return nil
}

func (m *Relay) GetDestId() []byte {
	if m != nil {
		return m.DestId
	}
	return nil
}

func (m *Relay) GetPayload() []byte {
	if m != nil {
		return m.Payload
	}
	return nil
}

func (m *Relay) GetMaxHoldingSeconds() uint32 {
	if m != nil {
		return m.MaxHoldingSeconds
	}
	return 0
}

func (m *Relay) GetBlockHash() []byte {
	if m != nil {
		return m.BlockHash
	}
	return nil
}

func (m *Relay) GetLastSignature() []byte {
	if m != nil {
		return m.LastSignature
	}
	return nil
}

func (m *Relay) GetSigChainLen() uint32 {
	if m != nil {
		return m.SigChainLen
	}
	return 0
}

type Transactions struct {
	Transactions []*Transaction `protobuf:"bytes,1,rep,name=transactions" json:"transactions,omitempty"`
}

func (m *Transactions) Reset()      { *m = Transactions{} }
func (*Transactions) ProtoMessage() {}
func (*Transactions) Descriptor() ([]byte, []int) {
	return fileDescriptor_nodemessage_c02ceb21668725d0, []int{15}
}
func (m *Transactions) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Transactions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Transactions.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *Transactions) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Transactions.Merge(dst, src)
}
func (m *Transactions) XXX_Size() int {
	return m.Size()
}
func (m *Transactions) XXX_DiscardUnknown() {
	xxx_messageInfo_Transactions.DiscardUnknown(m)
}

var xxx_messageInfo_Transactions proto.InternalMessageInfo

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

type BacktrackSignatureChain struct {
	SigChainElems []*SigChainElem `protobuf:"bytes,1,rep,name=sig_chain_elems,json=sigChainElems" json:"sig_chain_elems,omitempty"`
	PrevSignature []byte          `protobuf:"bytes,2,opt,name=prev_signature,json=prevSignature,proto3" json:"prev_signature,omitempty"`
}

func (m *BacktrackSignatureChain) Reset()      { *m = BacktrackSignatureChain{} }
func (*BacktrackSignatureChain) ProtoMessage() {}
func (*BacktrackSignatureChain) Descriptor() ([]byte, []int) {
	return fileDescriptor_nodemessage_c02ceb21668725d0, []int{16}
}
func (m *BacktrackSignatureChain) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BacktrackSignatureChain) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BacktrackSignatureChain.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *BacktrackSignatureChain) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BacktrackSignatureChain.Merge(dst, src)
}
func (m *BacktrackSignatureChain) XXX_Size() int {
	return m.Size()
}
func (m *BacktrackSignatureChain) XXX_DiscardUnknown() {
	xxx_messageInfo_BacktrackSignatureChain.DiscardUnknown(m)
}

var xxx_messageInfo_BacktrackSignatureChain proto.InternalMessageInfo

func (m *BacktrackSignatureChain) GetSigChainElems() []*SigChainElem {
	if m != nil {
		return m.SigChainElems
	}
	return nil
}

func (m *BacktrackSignatureChain) GetPrevSignature() []byte {
	if m != nil {
		return m.PrevSignature
	}
	return nil
}

type IHaveSignatureChainTransaction struct {
	Height        uint32 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
	SignatureHash []byte `protobuf:"bytes,2,opt,name=signature_hash,json=signatureHash,proto3" json:"signature_hash,omitempty"`
}

func (m *IHaveSignatureChainTransaction) Reset()      { *m = IHaveSignatureChainTransaction{} }
func (*IHaveSignatureChainTransaction) ProtoMessage() {}
func (*IHaveSignatureChainTransaction) Descriptor() ([]byte, []int) {
	return fileDescriptor_nodemessage_c02ceb21668725d0, []int{17}
}
func (m *IHaveSignatureChainTransaction) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *IHaveSignatureChainTransaction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_IHaveSignatureChainTransaction.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *IHaveSignatureChainTransaction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IHaveSignatureChainTransaction.Merge(dst, src)
}
func (m *IHaveSignatureChainTransaction) XXX_Size() int {
	return m.Size()
}
func (m *IHaveSignatureChainTransaction) XXX_DiscardUnknown() {
	xxx_messageInfo_IHaveSignatureChainTransaction.DiscardUnknown(m)
}

var xxx_messageInfo_IHaveSignatureChainTransaction proto.InternalMessageInfo

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

func (m *IHaveSignatureChainTransaction) GetSignatureHash() []byte {
	if m != nil {
		return m.SignatureHash
	}
	return nil
}

type RequestSignatureChainTransaction struct {
	SignatureHash []byte `protobuf:"bytes,1,opt,name=signature_hash,json=signatureHash,proto3" json:"signature_hash,omitempty"`
}

func (m *RequestSignatureChainTransaction) Reset()      { *m = RequestSignatureChainTransaction{} }
func (*RequestSignatureChainTransaction) ProtoMessage() {}
func (*RequestSignatureChainTransaction) Descriptor() ([]byte, []int) {
	return fileDescriptor_nodemessage_c02ceb21668725d0, []int{18}
}
func (m *RequestSignatureChainTransaction) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RequestSignatureChainTransaction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RequestSignatureChainTransaction.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *RequestSignatureChainTransaction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RequestSignatureChainTransaction.Merge(dst, src)
}
func (m *RequestSignatureChainTransaction) XXX_Size() int {
	return m.Size()
}
func (m *RequestSignatureChainTransaction) XXX_DiscardUnknown() {
	xxx_messageInfo_RequestSignatureChainTransaction.DiscardUnknown(m)
}

var xxx_messageInfo_RequestSignatureChainTransaction proto.InternalMessageInfo

func (m *RequestSignatureChainTransaction) GetSignatureHash() []byte {
	if m != nil {
		return m.SignatureHash
	}
	return nil
}

type RequestSignatureChainTransactionReply struct {
	Transaction *Transaction `protobuf:"bytes,1,opt,name=transaction" json:"transaction,omitempty"`
}

func (m *RequestSignatureChainTransactionReply) Reset()      { *m = RequestSignatureChainTransactionReply{} }
func (*RequestSignatureChainTransactionReply) ProtoMessage() {}
func (*RequestSignatureChainTransactionReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_nodemessage_c02ceb21668725d0, []int{19}
}
func (m *RequestSignatureChainTransactionReply) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RequestSignatureChainTransactionReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RequestSignatureChainTransactionReply.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *RequestSignatureChainTransactionReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RequestSignatureChainTransactionReply.Merge(dst, src)
}
func (m *RequestSignatureChainTransactionReply) XXX_Size() int {
	return m.Size()
}
func (m *RequestSignatureChainTransactionReply) XXX_DiscardUnknown() {
	xxx_messageInfo_RequestSignatureChainTransactionReply.DiscardUnknown(m)
}

var xxx_messageInfo_RequestSignatureChainTransactionReply proto.InternalMessageInfo

func (m *RequestSignatureChainTransactionReply) GetTransaction() *Transaction {
	if m != nil {
		return m.Transaction
	}
	return nil
}

func init() {
	proto.RegisterType((*UnsignedMessage)(nil), "pb.UnsignedMessage")
	proto.RegisterType((*SignedMessage)(nil), "pb.SignedMessage")
	proto.RegisterType((*Vote)(nil), "pb.Vote")
	proto.RegisterType((*IHaveBlockProposal)(nil), "pb.IHaveBlockProposal")
	proto.RegisterType((*RequestBlockProposal)(nil), "pb.RequestBlockProposal")
	proto.RegisterType((*RequestBlockProposalReply)(nil), "pb.RequestBlockProposalReply")
	proto.RegisterType((*RequestProposalTransactions)(nil), "pb.RequestProposalTransactions")
	proto.RegisterType((*RequestProposalTransactionsReply)(nil), "pb.RequestProposalTransactionsReply")
	proto.RegisterType((*GetConsensusState)(nil), "pb.GetConsensusState")
	proto.RegisterType((*GetConsensusStateReply)(nil), "pb.GetConsensusStateReply")
	proto.RegisterType((*GetBlockHeaders)(nil), "pb.GetBlockHeaders")
	proto.RegisterType((*GetBlockHeadersReply)(nil), "pb.GetBlockHeadersReply")
	proto.RegisterType((*GetBlocks)(nil), "pb.GetBlocks")
	proto.RegisterType((*GetBlocksReply)(nil), "pb.GetBlocksReply")
	proto.RegisterType((*Relay)(nil), "pb.Relay")
	proto.RegisterType((*Transactions)(nil), "pb.Transactions")
	proto.RegisterType((*BacktrackSignatureChain)(nil), "pb.BacktrackSignatureChain")
	proto.RegisterType((*IHaveSignatureChainTransaction)(nil), "pb.IHaveSignatureChainTransaction")
	proto.RegisterType((*RequestSignatureChainTransaction)(nil), "pb.RequestSignatureChainTransaction")
	proto.RegisterType((*RequestSignatureChainTransactionReply)(nil), "pb.RequestSignatureChainTransactionReply")
	proto.RegisterEnum("pb.MessageType", MessageType_name, MessageType_value)
	proto.RegisterEnum("pb.AllowedSignedMessageType", AllowedSignedMessageType_name, AllowedSignedMessageType_value)
	proto.RegisterEnum("pb.AllowedUnsignedMessageType", AllowedUnsignedMessageType_name, AllowedUnsignedMessageType_value)
	proto.RegisterEnum("pb.AllowedDirectMessageType", AllowedDirectMessageType_name, AllowedDirectMessageType_value)
	proto.RegisterEnum("pb.AllowedRelayMessageType", AllowedRelayMessageType_name, AllowedRelayMessageType_value)
	proto.RegisterEnum("pb.AllowedBroadcastPushMessageType", AllowedBroadcastPushMessageType_name, AllowedBroadcastPushMessageType_value)
	proto.RegisterEnum("pb.AllowedBroadcastPullMessageType", AllowedBroadcastPullMessageType_name, AllowedBroadcastPullMessageType_value)
	proto.RegisterEnum("pb.AllowedBroadcastTreeMessageType", AllowedBroadcastTreeMessageType_name, AllowedBroadcastTreeMessageType_value)
	proto.RegisterEnum("pb.RequestTransactionType", RequestTransactionType_name, RequestTransactionType_value)
}
func (x MessageType) String() string {
	s, ok := MessageType_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x AllowedSignedMessageType) String() string {
	s, ok := AllowedSignedMessageType_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x AllowedUnsignedMessageType) String() string {
	s, ok := AllowedUnsignedMessageType_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x AllowedDirectMessageType) String() string {
	s, ok := AllowedDirectMessageType_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x AllowedRelayMessageType) String() string {
	s, ok := AllowedRelayMessageType_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x AllowedBroadcastPushMessageType) String() string {
	s, ok := AllowedBroadcastPushMessageType_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x AllowedBroadcastPullMessageType) String() string {
	s, ok := AllowedBroadcastPullMessageType_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x AllowedBroadcastTreeMessageType) String() string {
	s, ok := AllowedBroadcastTreeMessageType_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x RequestTransactionType) String() string {
	s, ok := RequestTransactionType_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (this *UnsignedMessage) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*UnsignedMessage)
	if !ok {
		that2, ok := that.(UnsignedMessage)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.MessageType != that1.MessageType {
		return false
	}
	if !bytes.Equal(this.Message, that1.Message) {
		return false
	}
	return true
}
func (this *SignedMessage) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*SignedMessage)
	if !ok {
		that2, ok := that.(SignedMessage)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.Message, that1.Message) {
		return false
	}
	if !bytes.Equal(this.Signature, that1.Signature) {
		return false
	}
	return true
}
func (this *Vote) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Vote)
	if !ok {
		that2, ok := that.(Vote)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Height != that1.Height {
		return false
	}
	if !bytes.Equal(this.BlockHash, that1.BlockHash) {
		return false
	}
	return true
}
func (this *IHaveBlockProposal) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*IHaveBlockProposal)
	if !ok {
		that2, ok := that.(IHaveBlockProposal)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Height != that1.Height {
		return false
	}
	if !bytes.Equal(this.BlockHash, that1.BlockHash) {
		return false
	}
	return true
}
func (this *RequestBlockProposal) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RequestBlockProposal)
	if !ok {
		that2, ok := that.(RequestBlockProposal)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.BlockHash, that1.BlockHash) {
		return false
	}
	if this.Type != that1.Type {
		return false
	}
	if !bytes.Equal(this.ShortHashSalt, that1.ShortHashSalt) {
		return false
	}
	if this.ShortHashSize != that1.ShortHashSize {
		return false
	}
	return true
}
func (this *RequestBlockProposalReply) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RequestBlockProposalReply)
	if !ok {
		that2, ok := that.(RequestBlockProposalReply)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Block.Equal(that1.Block) {
		return false
	}
	if len(this.TransactionsHash) != len(that1.TransactionsHash) {
		return false
	}
	for i := range this.TransactionsHash {
		if !bytes.Equal(this.TransactionsHash[i], that1.TransactionsHash[i]) {
			return false
		}
	}
	return true
}
func (this *RequestProposalTransactions) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RequestProposalTransactions)
	if !ok {
		that2, ok := that.(RequestProposalTransactions)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.BlockHash, that1.BlockHash) {
		return false
	}
	if this.Type != that1.Type {
		return false
	}
	if !bytes.Equal(this.ShortHashSalt, that1.ShortHashSalt) {
		return false
	}
	if this.ShortHashSize != that1.ShortHashSize {
		return false
	}
	if len(this.TransactionsHash) != len(that1.TransactionsHash) {
		return false
	}
	for i := range this.TransactionsHash {
		if !bytes.Equal(this.TransactionsHash[i], that1.TransactionsHash[i]) {
			return false
		}
	}
	return true
}
func (this *RequestProposalTransactionsReply) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RequestProposalTransactionsReply)
	if !ok {
		that2, ok := that.(RequestProposalTransactionsReply)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Transactions) != len(that1.Transactions) {
		return false
	}
	for i := range this.Transactions {
		if !this.Transactions[i].Equal(that1.Transactions[i]) {
			return false
		}
	}
	return true
}
func (this *GetConsensusState) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GetConsensusState)
	if !ok {
		that2, ok := that.(GetConsensusState)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	return true
}
func (this *GetConsensusStateReply) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GetConsensusStateReply)
	if !ok {
		that2, ok := that.(GetConsensusStateReply)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.LedgerBlockHash, that1.LedgerBlockHash) {
		return false
	}
	if this.LedgerHeight != that1.LedgerHeight {
		return false
	}
	if this.ConsensusHeight != that1.ConsensusHeight {
		return false
	}
	if this.MinVerifiableHeight != that1.MinVerifiableHeight {
		return false
	}
	if this.SyncState != that1.SyncState {
		return false
	}
	return true
}
func (this *GetBlockHeaders) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GetBlockHeaders)
	if !ok {
		that2, ok := that.(GetBlockHeaders)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.StartHeight != that1.StartHeight {
		return false
	}
	if this.EndHeight != that1.EndHeight {
		return false
	}
	return true
}
func (this *GetBlockHeadersReply) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GetBlockHeadersReply)
	if !ok {
		that2, ok := that.(GetBlockHeadersReply)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.BlockHeaders) != len(that1.BlockHeaders) {
		return false
	}
	for i := range this.BlockHeaders {
		if !this.BlockHeaders[i].Equal(that1.BlockHeaders[i]) {
			return false
		}
	}
	return true
}
func (this *GetBlocks) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GetBlocks)
	if !ok {
		that2, ok := that.(GetBlocks)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.StartHeight != that1.StartHeight {
		return false
	}
	if this.EndHeight != that1.EndHeight {
		return false
	}
	return true
}
func (this *GetBlocksReply) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GetBlocksReply)
	if !ok {
		that2, ok := that.(GetBlocksReply)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Blocks) != len(that1.Blocks) {
		return false
	}
	for i := range this.Blocks {
		if !this.Blocks[i].Equal(that1.Blocks[i]) {
			return false
		}
	}
	return true
}
func (this *Relay) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Relay)
	if !ok {
		that2, ok := that.(Relay)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.SrcIdentifier != that1.SrcIdentifier {
		return false
	}
	if !bytes.Equal(this.SrcPubkey, that1.SrcPubkey) {
		return false
	}
	if !bytes.Equal(this.DestId, that1.DestId) {
		return false
	}
	if !bytes.Equal(this.Payload, that1.Payload) {
		return false
	}
	if this.MaxHoldingSeconds != that1.MaxHoldingSeconds {
		return false
	}
	if !bytes.Equal(this.BlockHash, that1.BlockHash) {
		return false
	}
	if !bytes.Equal(this.LastSignature, that1.LastSignature) {
		return false
	}
	if this.SigChainLen != that1.SigChainLen {
		return false
	}
	return true
}
func (this *Transactions) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Transactions)
	if !ok {
		that2, ok := that.(Transactions)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Transactions) != len(that1.Transactions) {
		return false
	}
	for i := range this.Transactions {
		if !this.Transactions[i].Equal(that1.Transactions[i]) {
			return false
		}
	}
	return true
}
func (this *BacktrackSignatureChain) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*BacktrackSignatureChain)
	if !ok {
		that2, ok := that.(BacktrackSignatureChain)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.SigChainElems) != len(that1.SigChainElems) {
		return false
	}
	for i := range this.SigChainElems {
		if !this.SigChainElems[i].Equal(that1.SigChainElems[i]) {
			return false
		}
	}
	if !bytes.Equal(this.PrevSignature, that1.PrevSignature) {
		return false
	}
	return true
}
func (this *IHaveSignatureChainTransaction) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*IHaveSignatureChainTransaction)
	if !ok {
		that2, ok := that.(IHaveSignatureChainTransaction)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Height != that1.Height {
		return false
	}
	if !bytes.Equal(this.SignatureHash, that1.SignatureHash) {
		return false
	}
	return true
}
func (this *RequestSignatureChainTransaction) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RequestSignatureChainTransaction)
	if !ok {
		that2, ok := that.(RequestSignatureChainTransaction)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.SignatureHash, that1.SignatureHash) {
		return false
	}
	return true
}
func (this *RequestSignatureChainTransactionReply) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RequestSignatureChainTransactionReply)
	if !ok {
		that2, ok := that.(RequestSignatureChainTransactionReply)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Transaction.Equal(that1.Transaction) {
		return false
	}
	return true
}
func (this *UnsignedMessage) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&pb.UnsignedMessage{")
	s = append(s, "MessageType: "+fmt.Sprintf("%#v", this.MessageType)+",\n")
	s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *SignedMessage) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&pb.SignedMessage{")
	s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\n")
	s = append(s, "Signature: "+fmt.Sprintf("%#v", this.Signature)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Vote) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&pb.Vote{")
	s = append(s, "Height: "+fmt.Sprintf("%#v", this.Height)+",\n")
	s = append(s, "BlockHash: "+fmt.Sprintf("%#v", this.BlockHash)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *IHaveBlockProposal) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&pb.IHaveBlockProposal{")
	s = append(s, "Height: "+fmt.Sprintf("%#v", this.Height)+",\n")
	s = append(s, "BlockHash: "+fmt.Sprintf("%#v", this.BlockHash)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *RequestBlockProposal) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&pb.RequestBlockProposal{")
	s = append(s, "BlockHash: "+fmt.Sprintf("%#v", this.BlockHash)+",\n")
	s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n")
	s = append(s, "ShortHashSalt: "+fmt.Sprintf("%#v", this.ShortHashSalt)+",\n")
	s = append(s, "ShortHashSize: "+fmt.Sprintf("%#v", this.ShortHashSize)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *RequestBlockProposalReply) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&pb.RequestBlockProposalReply{")
	if this.Block != nil {
		s = append(s, "Block: "+fmt.Sprintf("%#v", this.Block)+",\n")
	}
	s = append(s, "TransactionsHash: "+fmt.Sprintf("%#v", this.TransactionsHash)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *RequestProposalTransactions) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 9)
	s = append(s, "&pb.RequestProposalTransactions{")
	s = append(s, "BlockHash: "+fmt.Sprintf("%#v", this.BlockHash)+",\n")
	s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n")
	s = append(s, "ShortHashSalt: "+fmt.Sprintf("%#v", this.ShortHashSalt)+",\n")
	s = append(s, "ShortHashSize: "+fmt.Sprintf("%#v", this.ShortHashSize)+",\n")
	s = append(s, "TransactionsHash: "+fmt.Sprintf("%#v", this.TransactionsHash)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *RequestProposalTransactionsReply) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&pb.RequestProposalTransactionsReply{")
	if this.Transactions != nil {
		s = append(s, "Transactions: "+fmt.Sprintf("%#v", this.Transactions)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GetConsensusState) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 4)
	s = append(s, "&pb.GetConsensusState{")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GetConsensusStateReply) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 9)
	s = append(s, "&pb.GetConsensusStateReply{")
	s = append(s, "LedgerBlockHash: "+fmt.Sprintf("%#v", this.LedgerBlockHash)+",\n")
	s = append(s, "LedgerHeight: "+fmt.Sprintf("%#v", this.LedgerHeight)+",\n")
	s = append(s, "ConsensusHeight: "+fmt.Sprintf("%#v", this.ConsensusHeight)+",\n")
	s = append(s, "MinVerifiableHeight: "+fmt.Sprintf("%#v", this.MinVerifiableHeight)+",\n")
	s = append(s, "SyncState: "+fmt.Sprintf("%#v", this.SyncState)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GetBlockHeaders) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&pb.GetBlockHeaders{")
	s = append(s, "StartHeight: "+fmt.Sprintf("%#v", this.StartHeight)+",\n")
	s = append(s, "EndHeight: "+fmt.Sprintf("%#v", this.EndHeight)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GetBlockHeadersReply) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&pb.GetBlockHeadersReply{")
	if this.BlockHeaders != nil {
		s = append(s, "BlockHeaders: "+fmt.Sprintf("%#v", this.BlockHeaders)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GetBlocks) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&pb.GetBlocks{")
	s = append(s, "StartHeight: "+fmt.Sprintf("%#v", this.StartHeight)+",\n")
	s = append(s, "EndHeight: "+fmt.Sprintf("%#v", this.EndHeight)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GetBlocksReply) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&pb.GetBlocksReply{")
	if this.Blocks != nil {
		s = append(s, "Blocks: "+fmt.Sprintf("%#v", this.Blocks)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Relay) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 12)
	s = append(s, "&pb.Relay{")
	s = append(s, "SrcIdentifier: "+fmt.Sprintf("%#v", this.SrcIdentifier)+",\n")
	s = append(s, "SrcPubkey: "+fmt.Sprintf("%#v", this.SrcPubkey)+",\n")
	s = append(s, "DestId: "+fmt.Sprintf("%#v", this.DestId)+",\n")
	s = append(s, "Payload: "+fmt.Sprintf("%#v", this.Payload)+",\n")
	s = append(s, "MaxHoldingSeconds: "+fmt.Sprintf("%#v", this.MaxHoldingSeconds)+",\n")
	s = append(s, "BlockHash: "+fmt.Sprintf("%#v", this.BlockHash)+",\n")
	s = append(s, "LastSignature: "+fmt.Sprintf("%#v", this.LastSignature)+",\n")
	s = append(s, "SigChainLen: "+fmt.Sprintf("%#v", this.SigChainLen)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Transactions) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&pb.Transactions{")
	if this.Transactions != nil {
		s = append(s, "Transactions: "+fmt.Sprintf("%#v", this.Transactions)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *BacktrackSignatureChain) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&pb.BacktrackSignatureChain{")
	if this.SigChainElems != nil {
		s = append(s, "SigChainElems: "+fmt.Sprintf("%#v", this.SigChainElems)+",\n")
	}
	s = append(s, "PrevSignature: "+fmt.Sprintf("%#v", this.PrevSignature)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *IHaveSignatureChainTransaction) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&pb.IHaveSignatureChainTransaction{")
	s = append(s, "Height: "+fmt.Sprintf("%#v", this.Height)+",\n")
	s = append(s, "SignatureHash: "+fmt.Sprintf("%#v", this.SignatureHash)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *RequestSignatureChainTransaction) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&pb.RequestSignatureChainTransaction{")
	s = append(s, "SignatureHash: "+fmt.Sprintf("%#v", this.SignatureHash)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *RequestSignatureChainTransactionReply) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&pb.RequestSignatureChainTransactionReply{")
	if this.Transaction != nil {
		s = append(s, "Transaction: "+fmt.Sprintf("%#v", this.Transaction)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringNodemessage(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}
func (m *UnsignedMessage) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UnsignedMessage) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.MessageType != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(m.MessageType))
	}
	if len(m.Message) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(len(m.Message)))
		i += copy(dAtA[i:], m.Message)
	}
	return i, nil
}

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

func (m *SignedMessage) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Message) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(len(m.Message)))
		i += copy(dAtA[i:], m.Message)
	}
	if len(m.Signature) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(len(m.Signature)))
		i += copy(dAtA[i:], m.Signature)
	}
	return i, nil
}

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

func (m *Vote) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Height != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(m.Height))
	}
	if len(m.BlockHash) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(len(m.BlockHash)))
		i += copy(dAtA[i:], m.BlockHash)
	}
	return i, nil
}

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

func (m *IHaveBlockProposal) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Height != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(m.Height))
	}
	if len(m.BlockHash) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(len(m.BlockHash)))
		i += copy(dAtA[i:], m.BlockHash)
	}
	return i, nil
}

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

func (m *RequestBlockProposal) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.BlockHash) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(len(m.BlockHash)))
		i += copy(dAtA[i:], m.BlockHash)
	}
	if m.Type != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(m.Type))
	}
	if len(m.ShortHashSalt) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(len(m.ShortHashSalt)))
		i += copy(dAtA[i:], m.ShortHashSalt)
	}
	if m.ShortHashSize != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(m.ShortHashSize))
	}
	return i, nil
}

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

func (m *RequestBlockProposalReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Block != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(m.Block.Size()))
		n1, err := m.Block.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	if len(m.TransactionsHash) > 0 {
		for _, b := range m.TransactionsHash {
			dAtA[i] = 0x12
			i++
			i = encodeVarintNodemessage(dAtA, i, uint64(len(b)))
			i += copy(dAtA[i:], b)
		}
	}
	return i, nil
}

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

func (m *RequestProposalTransactions) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.BlockHash) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(len(m.BlockHash)))
		i += copy(dAtA[i:], m.BlockHash)
	}
	if m.Type != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(m.Type))
	}
	if len(m.ShortHashSalt) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(len(m.ShortHashSalt)))
		i += copy(dAtA[i:], m.ShortHashSalt)
	}
	if m.ShortHashSize != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(m.ShortHashSize))
	}
	if len(m.TransactionsHash) > 0 {
		for _, b := range m.TransactionsHash {
			dAtA[i] = 0x2a
			i++
			i = encodeVarintNodemessage(dAtA, i, uint64(len(b)))
			i += copy(dAtA[i:], b)
		}
	}
	return i, nil
}

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

func (m *RequestProposalTransactionsReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Transactions) > 0 {
		for _, msg := range m.Transactions {
			dAtA[i] = 0xa
			i++
			i = encodeVarintNodemessage(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

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

func (m *GetConsensusState) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

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

func (m *GetConsensusStateReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.LedgerHeight != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(m.LedgerHeight))
	}
	if len(m.LedgerBlockHash) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(len(m.LedgerBlockHash)))
		i += copy(dAtA[i:], m.LedgerBlockHash)
	}
	if m.ConsensusHeight != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(m.ConsensusHeight))
	}
	if m.SyncState != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(m.SyncState))
	}
	if m.MinVerifiableHeight != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(m.MinVerifiableHeight))
	}
	return i, nil
}

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

func (m *GetBlockHeaders) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.StartHeight != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(m.StartHeight))
	}
	if m.EndHeight != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(m.EndHeight))
	}
	return i, nil
}

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

func (m *GetBlockHeadersReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.BlockHeaders) > 0 {
		for _, msg := range m.BlockHeaders {
			dAtA[i] = 0xa
			i++
			i = encodeVarintNodemessage(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

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

func (m *GetBlocks) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.StartHeight != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(m.StartHeight))
	}
	if m.EndHeight != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(m.EndHeight))
	}
	return i, nil
}

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

func (m *GetBlocksReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Blocks) > 0 {
		for _, msg := range m.Blocks {
			dAtA[i] = 0xa
			i++
			i = encodeVarintNodemessage(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

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

func (m *Relay) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.SrcIdentifier) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(len(m.SrcIdentifier)))
		i += copy(dAtA[i:], m.SrcIdentifier)
	}
	if len(m.DestId) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(len(m.DestId)))
		i += copy(dAtA[i:], m.DestId)
	}
	if len(m.Payload) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(len(m.Payload)))
		i += copy(dAtA[i:], m.Payload)
	}
	if m.MaxHoldingSeconds != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(m.MaxHoldingSeconds))
	}
	if len(m.SrcPubkey) > 0 {
		dAtA[i] = 0x32
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(len(m.SrcPubkey)))
		i += copy(dAtA[i:], m.SrcPubkey)
	}
	if len(m.BlockHash) > 0 {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(len(m.BlockHash)))
		i += copy(dAtA[i:], m.BlockHash)
	}
	if len(m.LastSignature) > 0 {
		dAtA[i] = 0x42
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(len(m.LastSignature)))
		i += copy(dAtA[i:], m.LastSignature)
	}
	if m.SigChainLen != 0 {
		dAtA[i] = 0x48
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(m.SigChainLen))
	}
	return i, nil
}

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

func (m *Transactions) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Transactions) > 0 {
		for _, msg := range m.Transactions {
			dAtA[i] = 0xa
			i++
			i = encodeVarintNodemessage(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

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

func (m *BacktrackSignatureChain) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.SigChainElems) > 0 {
		for _, msg := range m.SigChainElems {
			dAtA[i] = 0xa
			i++
			i = encodeVarintNodemessage(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.PrevSignature) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(len(m.PrevSignature)))
		i += copy(dAtA[i:], m.PrevSignature)
	}
	return i, nil
}

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

func (m *IHaveSignatureChainTransaction) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Height != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(m.Height))
	}
	if len(m.SignatureHash) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(len(m.SignatureHash)))
		i += copy(dAtA[i:], m.SignatureHash)
	}
	return i, nil
}

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

func (m *RequestSignatureChainTransaction) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.SignatureHash) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(len(m.SignatureHash)))
		i += copy(dAtA[i:], m.SignatureHash)
	}
	return i, nil
}

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

func (m *RequestSignatureChainTransactionReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Transaction != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintNodemessage(dAtA, i, uint64(m.Transaction.Size()))
		n2, err := m.Transaction.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	return i, nil
}

func encodeVarintNodemessage(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func NewPopulatedUnsignedMessage(r randyNodemessage, easy bool) *UnsignedMessage {
	this := &UnsignedMessage{}
	this.MessageType = MessageType([]int32{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18}[r.Intn(19)])
	v1 := r.Intn(100)
	this.Message = make([]byte, v1)
	for i := 0; i < v1; i++ {
		this.Message[i] = byte(r.Intn(256))
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedSignedMessage(r randyNodemessage, easy bool) *SignedMessage {
	this := &SignedMessage{}
	v2 := r.Intn(100)
	this.Message = make([]byte, v2)
	for i := 0; i < v2; i++ {
		this.Message[i] = byte(r.Intn(256))
	}
	v3 := r.Intn(100)
	this.Signature = make([]byte, v3)
	for i := 0; i < v3; i++ {
		this.Signature[i] = byte(r.Intn(256))
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedVote(r randyNodemessage, easy bool) *Vote {
	this := &Vote{}
	this.Height = uint32(r.Uint32())
	v4 := r.Intn(100)
	this.BlockHash = make([]byte, v4)
	for i := 0; i < v4; i++ {
		this.BlockHash[i] = byte(r.Intn(256))
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedIHaveBlockProposal(r randyNodemessage, easy bool) *IHaveBlockProposal {
	this := &IHaveBlockProposal{}
	this.Height = uint32(r.Uint32())
	v5 := r.Intn(100)
	this.BlockHash = make([]byte, v5)
	for i := 0; i < v5; i++ {
		this.BlockHash[i] = byte(r.Intn(256))
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedRequestBlockProposal(r randyNodemessage, easy bool) *RequestBlockProposal {
	this := &RequestBlockProposal{}
	v6 := r.Intn(100)
	this.BlockHash = make([]byte, v6)
	for i := 0; i < v6; i++ {
		this.BlockHash[i] = byte(r.Intn(256))
	}
	this.Type = RequestTransactionType([]int32{0, 1, 2}[r.Intn(3)])
	v7 := r.Intn(100)
	this.ShortHashSalt = make([]byte, v7)
	for i := 0; i < v7; i++ {
		this.ShortHashSalt[i] = byte(r.Intn(256))
	}
	this.ShortHashSize = uint32(r.Uint32())
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedRequestBlockProposalReply(r randyNodemessage, easy bool) *RequestBlockProposalReply {
	this := &RequestBlockProposalReply{}
	if r.Intn(10) != 0 {
		this.Block = NewPopulatedBlock(r, easy)
	}
	v8 := r.Intn(10)
	this.TransactionsHash = make([][]byte, v8)
	for i := 0; i < v8; i++ {
		v9 := r.Intn(100)
		this.TransactionsHash[i] = make([]byte, v9)
		for j := 0; j < v9; j++ {
			this.TransactionsHash[i][j] = byte(r.Intn(256))
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedRequestProposalTransactions(r randyNodemessage, easy bool) *RequestProposalTransactions {
	this := &RequestProposalTransactions{}
	v10 := r.Intn(100)
	this.BlockHash = make([]byte, v10)
	for i := 0; i < v10; i++ {
		this.BlockHash[i] = byte(r.Intn(256))
	}
	this.Type = RequestTransactionType([]int32{0, 1, 2}[r.Intn(3)])
	v11 := r.Intn(100)
	this.ShortHashSalt = make([]byte, v11)
	for i := 0; i < v11; i++ {
		this.ShortHashSalt[i] = byte(r.Intn(256))
	}
	this.ShortHashSize = uint32(r.Uint32())
	v12 := r.Intn(10)
	this.TransactionsHash = make([][]byte, v12)
	for i := 0; i < v12; i++ {
		v13 := r.Intn(100)
		this.TransactionsHash[i] = make([]byte, v13)
		for j := 0; j < v13; j++ {
			this.TransactionsHash[i][j] = byte(r.Intn(256))
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedRequestProposalTransactionsReply(r randyNodemessage, easy bool) *RequestProposalTransactionsReply {
	this := &RequestProposalTransactionsReply{}
	if r.Intn(10) != 0 {
		v14 := r.Intn(5)
		this.Transactions = make([]*Transaction, v14)
		for i := 0; i < v14; i++ {
			this.Transactions[i] = NewPopulatedTransaction(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedGetConsensusState(r randyNodemessage, easy bool) *GetConsensusState {
	this := &GetConsensusState{}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedGetConsensusStateReply(r randyNodemessage, easy bool) *GetConsensusStateReply {
	this := &GetConsensusStateReply{}
	this.LedgerHeight = uint32(r.Uint32())
	v15 := r.Intn(100)
	this.LedgerBlockHash = make([]byte, v15)
	for i := 0; i < v15; i++ {
		this.LedgerBlockHash[i] = byte(r.Intn(256))
	}
	this.ConsensusHeight = uint32(r.Uint32())
	this.SyncState = SyncState([]int32{0, 1, 2, 3}[r.Intn(4)])
	this.MinVerifiableHeight = uint32(r.Uint32())
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedGetBlockHeaders(r randyNodemessage, easy bool) *GetBlockHeaders {
	this := &GetBlockHeaders{}
	this.StartHeight = uint32(r.Uint32())
	this.EndHeight = uint32(r.Uint32())
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedGetBlockHeadersReply(r randyNodemessage, easy bool) *GetBlockHeadersReply {
	this := &GetBlockHeadersReply{}
	if r.Intn(10) != 0 {
		v16 := r.Intn(5)
		this.BlockHeaders = make([]*Header, v16)
		for i := 0; i < v16; i++ {
			this.BlockHeaders[i] = NewPopulatedHeader(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedGetBlocks(r randyNodemessage, easy bool) *GetBlocks {
	this := &GetBlocks{}
	this.StartHeight = uint32(r.Uint32())
	this.EndHeight = uint32(r.Uint32())
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedGetBlocksReply(r randyNodemessage, easy bool) *GetBlocksReply {
	this := &GetBlocksReply{}
	if r.Intn(10) != 0 {
		v17 := r.Intn(5)
		this.Blocks = make([]*Block, v17)
		for i := 0; i < v17; i++ {
			this.Blocks[i] = NewPopulatedBlock(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedRelay(r randyNodemessage, easy bool) *Relay {
	this := &Relay{}
	this.SrcIdentifier = string(randStringNodemessage(r))
	v18 := r.Intn(100)
	this.DestId = make([]byte, v18)
	for i := 0; i < v18; i++ {
		this.DestId[i] = byte(r.Intn(256))
	}
	v19 := r.Intn(100)
	this.Payload = make([]byte, v19)
	for i := 0; i < v19; i++ {
		this.Payload[i] = byte(r.Intn(256))
	}
	this.MaxHoldingSeconds = uint32(r.Uint32())
	v20 := r.Intn(100)
	this.SrcPubkey = make([]byte, v20)
	for i := 0; i < v20; i++ {
		this.SrcPubkey[i] = byte(r.Intn(256))
	}
	v21 := r.Intn(100)
	this.BlockHash = make([]byte, v21)
	for i := 0; i < v21; i++ {
		this.BlockHash[i] = byte(r.Intn(256))
	}
	v22 := r.Intn(100)
	this.LastSignature = make([]byte, v22)
	for i := 0; i < v22; i++ {
		this.LastSignature[i] = byte(r.Intn(256))
	}
	this.SigChainLen = uint32(r.Uint32())
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedTransactions(r randyNodemessage, easy bool) *Transactions {
	this := &Transactions{}
	if r.Intn(10) != 0 {
		v23 := r.Intn(5)
		this.Transactions = make([]*Transaction, v23)
		for i := 0; i < v23; i++ {
			this.Transactions[i] = NewPopulatedTransaction(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedBacktrackSignatureChain(r randyNodemessage, easy bool) *BacktrackSignatureChain {
	this := &BacktrackSignatureChain{}
	if r.Intn(10) != 0 {
		v24 := r.Intn(5)
		this.SigChainElems = make([]*SigChainElem, v24)
		for i := 0; i < v24; i++ {
			this.SigChainElems[i] = NewPopulatedSigChainElem(r, easy)
		}
	}
	v25 := r.Intn(100)
	this.PrevSignature = make([]byte, v25)
	for i := 0; i < v25; i++ {
		this.PrevSignature[i] = byte(r.Intn(256))
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedIHaveSignatureChainTransaction(r randyNodemessage, easy bool) *IHaveSignatureChainTransaction {
	this := &IHaveSignatureChainTransaction{}
	this.Height = uint32(r.Uint32())
	v26 := r.Intn(100)
	this.SignatureHash = make([]byte, v26)
	for i := 0; i < v26; i++ {
		this.SignatureHash[i] = byte(r.Intn(256))
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedRequestSignatureChainTransaction(r randyNodemessage, easy bool) *RequestSignatureChainTransaction {
	this := &RequestSignatureChainTransaction{}
	v27 := r.Intn(100)
	this.SignatureHash = make([]byte, v27)
	for i := 0; i < v27; i++ {
		this.SignatureHash[i] = byte(r.Intn(256))
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedRequestSignatureChainTransactionReply(r randyNodemessage, easy bool) *RequestSignatureChainTransactionReply {
	this := &RequestSignatureChainTransactionReply{}
	if r.Intn(10) != 0 {
		this.Transaction = NewPopulatedTransaction(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

type randyNodemessage interface {
	Float32() float32
	Float64() float64
	Int63() int64
	Int31() int32
	Uint32() uint32
	Intn(n int) int
}

func randUTF8RuneNodemessage(r randyNodemessage) rune {
	ru := r.Intn(62)
	if ru < 10 {
		return rune(ru + 48)
	} else if ru < 36 {
		return rune(ru + 55)
	}
	return rune(ru + 61)
}
func randStringNodemessage(r randyNodemessage) string {
	v28 := r.Intn(100)
	tmps := make([]rune, v28)
	for i := 0; i < v28; i++ {
		tmps[i] = randUTF8RuneNodemessage(r)
	}
	return string(tmps)
}
func randUnrecognizedNodemessage(r randyNodemessage, maxFieldNumber int) (dAtA []byte) {
	l := r.Intn(5)
	for i := 0; i < l; i++ {
		wire := r.Intn(4)
		if wire == 3 {
			wire = 5
		}
		fieldNumber := maxFieldNumber + r.Intn(100)
		dAtA = randFieldNodemessage(dAtA, r, fieldNumber, wire)
	}
	return dAtA
}
func randFieldNodemessage(dAtA []byte, r randyNodemessage, fieldNumber int, wire int) []byte {
	key := uint32(fieldNumber)<<3 | uint32(wire)
	switch wire {
	case 0:
		dAtA = encodeVarintPopulateNodemessage(dAtA, uint64(key))
		v29 := r.Int63()
		if r.Intn(2) == 0 {
			v29 *= -1
		}
		dAtA = encodeVarintPopulateNodemessage(dAtA, uint64(v29))
	case 1:
		dAtA = encodeVarintPopulateNodemessage(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	case 2:
		dAtA = encodeVarintPopulateNodemessage(dAtA, uint64(key))
		ll := r.Intn(100)
		dAtA = encodeVarintPopulateNodemessage(dAtA, uint64(ll))
		for j := 0; j < ll; j++ {
			dAtA = append(dAtA, byte(r.Intn(256)))
		}
	default:
		dAtA = encodeVarintPopulateNodemessage(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	}
	return dAtA
}
func encodeVarintPopulateNodemessage(dAtA []byte, v uint64) []byte {
	for v >= 1<<7 {
		dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
		v >>= 7
	}
	dAtA = append(dAtA, uint8(v))
	return dAtA
}
func (m *UnsignedMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MessageType != 0 {
		n += 1 + sovNodemessage(uint64(m.MessageType))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovNodemessage(uint64(l))
	}
	return n
}

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

func (m *Vote) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Height != 0 {
		n += 1 + sovNodemessage(uint64(m.Height))
	}
	l = len(m.BlockHash)
	if l > 0 {
		n += 1 + l + sovNodemessage(uint64(l))
	}
	return n
}

func (m *IHaveBlockProposal) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Height != 0 {
		n += 1 + sovNodemessage(uint64(m.Height))
	}
	l = len(m.BlockHash)
	if l > 0 {
		n += 1 + l + sovNodemessage(uint64(l))
	}
	return n
}

func (m *RequestBlockProposal) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.BlockHash)
	if l > 0 {
		n += 1 + l + sovNodemessage(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovNodemessage(uint64(m.Type))
	}
	l = len(m.ShortHashSalt)
	if l > 0 {
		n += 1 + l + sovNodemessage(uint64(l))
	}
	if m.ShortHashSize != 0 {
		n += 1 + sovNodemessage(uint64(m.ShortHashSize))
	}
	return n
}

func (m *RequestBlockProposalReply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Block != nil {
		l = m.Block.Size()
		n += 1 + l + sovNodemessage(uint64(l))
	}
	if len(m.TransactionsHash) > 0 {
		for _, b := range m.TransactionsHash {
			l = len(b)
			n += 1 + l + sovNodemessage(uint64(l))
		}
	}
	return n
}

func (m *RequestProposalTransactions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.BlockHash)
	if l > 0 {
		n += 1 + l + sovNodemessage(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovNodemessage(uint64(m.Type))
	}
	l = len(m.ShortHashSalt)
	if l > 0 {
		n += 1 + l + sovNodemessage(uint64(l))
	}
	if m.ShortHashSize != 0 {
		n += 1 + sovNodemessage(uint64(m.ShortHashSize))
	}
	if len(m.TransactionsHash) > 0 {
		for _, b := range m.TransactionsHash {
			l = len(b)
			n += 1 + l + sovNodemessage(uint64(l))
		}
	}
	return n
}

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

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

func (m *GetConsensusStateReply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.LedgerHeight != 0 {
		n += 1 + sovNodemessage(uint64(m.LedgerHeight))
	}
	l = len(m.LedgerBlockHash)
	if l > 0 {
		n += 1 + l + sovNodemessage(uint64(l))
	}
	if m.ConsensusHeight != 0 {
		n += 1 + sovNodemessage(uint64(m.ConsensusHeight))
	}
	if m.SyncState != 0 {
		n += 1 + sovNodemessage(uint64(m.SyncState))
	}
	if m.MinVerifiableHeight != 0 {
		n += 1 + sovNodemessage(uint64(m.MinVerifiableHeight))
	}
	return n
}

func (m *GetBlockHeaders) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StartHeight != 0 {
		n += 1 + sovNodemessage(uint64(m.StartHeight))
	}
	if m.EndHeight != 0 {
		n += 1 + sovNodemessage(uint64(m.EndHeight))
	}
	return n
}

func (m *GetBlockHeadersReply) 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 + sovNodemessage(uint64(l))
		}
	}
	return n
}

func (m *GetBlocks) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StartHeight != 0 {
		n += 1 + sovNodemessage(uint64(m.StartHeight))
	}
	if m.EndHeight != 0 {
		n += 1 + sovNodemessage(uint64(m.EndHeight))
	}
	return n
}

func (m *GetBlocksReply) 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 + sovNodemessage(uint64(l))
		}
	}
	return n
}

func (m *Relay) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SrcIdentifier)
	if l > 0 {
		n += 1 + l + sovNodemessage(uint64(l))
	}
	l = len(m.DestId)
	if l > 0 {
		n += 1 + l + sovNodemessage(uint64(l))
	}
	l = len(m.Payload)
	if l > 0 {
		n += 1 + l + sovNodemessage(uint64(l))
	}
	if m.MaxHoldingSeconds != 0 {
		n += 1 + sovNodemessage(uint64(m.MaxHoldingSeconds))
	}
	l = len(m.SrcPubkey)
	if l > 0 {
		n += 1 + l + sovNodemessage(uint64(l))
	}
	l = len(m.BlockHash)
	if l > 0 {
		n += 1 + l + sovNodemessage(uint64(l))
	}
	l = len(m.LastSignature)
	if l > 0 {
		n += 1 + l + sovNodemessage(uint64(l))
	}
	if m.SigChainLen != 0 {
		n += 1 + sovNodemessage(uint64(m.SigChainLen))
	}
	return n
}

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

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

func (m *IHaveSignatureChainTransaction) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Height != 0 {
		n += 1 + sovNodemessage(uint64(m.Height))
	}
	l = len(m.SignatureHash)
	if l > 0 {
		n += 1 + l + sovNodemessage(uint64(l))
	}
	return n
}

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

func (m *RequestSignatureChainTransactionReply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Transaction != nil {
		l = m.Transaction.Size()
		n += 1 + l + sovNodemessage(uint64(l))
	}
	return n
}

func sovNodemessage(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozNodemessage(x uint64) (n int) {
	return sovNodemessage(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *UnsignedMessage) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&UnsignedMessage{`,
		`MessageType:` + fmt.Sprintf("%v", this.MessageType) + `,`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SignedMessage) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SignedMessage{`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`Signature:` + fmt.Sprintf("%v", this.Signature) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Vote) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Vote{`,
		`Height:` + fmt.Sprintf("%v", this.Height) + `,`,
		`BlockHash:` + fmt.Sprintf("%v", this.BlockHash) + `,`,
		`}`,
	}, "")
	return s
}
func (this *IHaveBlockProposal) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&IHaveBlockProposal{`,
		`Height:` + fmt.Sprintf("%v", this.Height) + `,`,
		`BlockHash:` + fmt.Sprintf("%v", this.BlockHash) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RequestBlockProposal) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RequestBlockProposal{`,
		`BlockHash:` + fmt.Sprintf("%v", this.BlockHash) + `,`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`ShortHashSalt:` + fmt.Sprintf("%v", this.ShortHashSalt) + `,`,
		`ShortHashSize:` + fmt.Sprintf("%v", this.ShortHashSize) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RequestBlockProposalReply) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RequestBlockProposalReply{`,
		`Block:` + strings.Replace(fmt.Sprintf("%v", this.Block), "Block", "Block", 1) + `,`,
		`TransactionsHash:` + fmt.Sprintf("%v", this.TransactionsHash) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RequestProposalTransactions) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RequestProposalTransactions{`,
		`BlockHash:` + fmt.Sprintf("%v", this.BlockHash) + `,`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`ShortHashSalt:` + fmt.Sprintf("%v", this.ShortHashSalt) + `,`,
		`ShortHashSize:` + fmt.Sprintf("%v", this.ShortHashSize) + `,`,
		`TransactionsHash:` + fmt.Sprintf("%v", this.TransactionsHash) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RequestProposalTransactionsReply) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RequestProposalTransactionsReply{`,
		`Transactions:` + strings.Replace(fmt.Sprintf("%v", this.Transactions), "Transaction", "Transaction", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetConsensusState) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GetConsensusState{`,
		`}`,
	}, "")
	return s
}
func (this *GetConsensusStateReply) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GetConsensusStateReply{`,
		`LedgerHeight:` + fmt.Sprintf("%v", this.LedgerHeight) + `,`,
		`LedgerBlockHash:` + fmt.Sprintf("%v", this.LedgerBlockHash) + `,`,
		`ConsensusHeight:` + fmt.Sprintf("%v", this.ConsensusHeight) + `,`,
		`SyncState:` + fmt.Sprintf("%v", this.SyncState) + `,`,
		`MinVerifiableHeight:` + fmt.Sprintf("%v", this.MinVerifiableHeight) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetBlockHeaders) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GetBlockHeaders{`,
		`StartHeight:` + fmt.Sprintf("%v", this.StartHeight) + `,`,
		`EndHeight:` + fmt.Sprintf("%v", this.EndHeight) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetBlockHeadersReply) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GetBlockHeadersReply{`,
		`BlockHeaders:` + strings.Replace(fmt.Sprintf("%v", this.BlockHeaders), "Header", "Header", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetBlocks) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GetBlocks{`,
		`StartHeight:` + fmt.Sprintf("%v", this.StartHeight) + `,`,
		`EndHeight:` + fmt.Sprintf("%v", this.EndHeight) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetBlocksReply) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GetBlocksReply{`,
		`Blocks:` + strings.Replace(fmt.Sprintf("%v", this.Blocks), "Block", "Block", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Relay) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Relay{`,
		`SrcIdentifier:` + fmt.Sprintf("%v", this.SrcIdentifier) + `,`,
		`DestId:` + fmt.Sprintf("%v", this.DestId) + `,`,
		`Payload:` + fmt.Sprintf("%v", this.Payload) + `,`,
		`MaxHoldingSeconds:` + fmt.Sprintf("%v", this.MaxHoldingSeconds) + `,`,
		`SrcPubkey:` + fmt.Sprintf("%v", this.SrcPubkey) + `,`,
		`BlockHash:` + fmt.Sprintf("%v", this.BlockHash) + `,`,
		`LastSignature:` + fmt.Sprintf("%v", this.LastSignature) + `,`,
		`SigChainLen:` + fmt.Sprintf("%v", this.SigChainLen) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Transactions) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Transactions{`,
		`Transactions:` + strings.Replace(fmt.Sprintf("%v", this.Transactions), "Transaction", "Transaction", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *BacktrackSignatureChain) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&BacktrackSignatureChain{`,
		`SigChainElems:` + strings.Replace(fmt.Sprintf("%v", this.SigChainElems), "SigChainElem", "SigChainElem", 1) + `,`,
		`PrevSignature:` + fmt.Sprintf("%v", this.PrevSignature) + `,`,
		`}`,
	}, "")
	return s
}
func (this *IHaveSignatureChainTransaction) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&IHaveSignatureChainTransaction{`,
		`Height:` + fmt.Sprintf("%v", this.Height) + `,`,
		`SignatureHash:` + fmt.Sprintf("%v", this.SignatureHash) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RequestSignatureChainTransaction) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RequestSignatureChainTransaction{`,
		`SignatureHash:` + fmt.Sprintf("%v", this.SignatureHash) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RequestSignatureChainTransactionReply) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RequestSignatureChainTransactionReply{`,
		`Transaction:` + strings.Replace(fmt.Sprintf("%v", this.Transaction), "Transaction", "Transaction", 1) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringNodemessage(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *UnsignedMessage) 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 ErrIntOverflowNodemessage
			}
			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: UnsignedMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UnsignedMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MessageType", wireType)
			}
			m.MessageType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNodemessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MessageType |= (MessageType(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNodemessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNodemessage
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = append(m.Message[:0], dAtA[iNdEx:postIndex]...)
			if m.Message == nil {
				m.Message = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNodemessage(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNodemessage
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RequestProposalTransactions) 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 ErrIntOverflowNodemessage
			}
			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: RequestProposalTransactions: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RequestProposalTransactions: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNodemessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNodemessage
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockHash = append(m.BlockHash[:0], dAtA[iNdEx:postIndex]...)
			if m.BlockHash == nil {
				m.BlockHash = []byte{}
			}
			iNdEx = postIndex
		case 2:
			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 ErrIntOverflowNodemessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= (RequestTransactionType(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ShortHashSalt", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNodemessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNodemessage
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ShortHashSalt = append(m.ShortHashSalt[:0], dAtA[iNdEx:postIndex]...)
			if m.ShortHashSalt == nil {
				m.ShortHashSalt = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ShortHashSize", wireType)
			}
			m.ShortHashSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNodemessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ShortHashSize |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TransactionsHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNodemessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNodemessage
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TransactionsHash = append(m.TransactionsHash, make([]byte, postIndex-iNdEx))
			copy(m.TransactionsHash[len(m.TransactionsHash)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNodemessage(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNodemessage
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RequestProposalTransactionsReply) 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 ErrIntOverflowNodemessage
			}
			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: RequestProposalTransactionsReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RequestProposalTransactionsReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowNodemessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNodemessage
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Transactions = append(m.Transactions, &Transaction{})
			if err := m.Transactions[len(m.Transactions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNodemessage(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNodemessage
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetConsensusStateReply) 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 ErrIntOverflowNodemessage
			}
			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: GetConsensusStateReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetConsensusStateReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LedgerHeight", wireType)
			}
			m.LedgerHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNodemessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LedgerHeight |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LedgerBlockHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNodemessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNodemessage
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LedgerBlockHash = append(m.LedgerBlockHash[:0], dAtA[iNdEx:postIndex]...)
			if m.LedgerBlockHash == nil {
				m.LedgerBlockHash = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConsensusHeight", wireType)
			}
			m.ConsensusHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNodemessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ConsensusHeight |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SyncState", wireType)
			}
			m.SyncState = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNodemessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SyncState |= (SyncState(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinVerifiableHeight", wireType)
			}
			m.MinVerifiableHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNodemessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MinVerifiableHeight |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipNodemessage(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNodemessage
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetBlockHeadersReply) 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 ErrIntOverflowNodemessage
			}
			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: GetBlockHeadersReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetBlockHeadersReply: 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 ErrIntOverflowNodemessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNodemessage
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockHeaders = append(m.BlockHeaders, &Header{})
			if err := m.BlockHeaders[len(m.BlockHeaders)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNodemessage(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNodemessage
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetBlocksReply) 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 ErrIntOverflowNodemessage
			}
			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: GetBlocksReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetBlocksReply: 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 ErrIntOverflowNodemessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNodemessage
			}
			postIndex := iNdEx + msglen
			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 := skipNodemessage(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNodemessage
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Relay) 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 ErrIntOverflowNodemessage
			}
			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: Relay: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Relay: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SrcIdentifier", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNodemessage
				}
				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 ErrInvalidLengthNodemessage
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SrcIdentifier = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DestId", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNodemessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNodemessage
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DestId = append(m.DestId[:0], dAtA[iNdEx:postIndex]...)
			if m.DestId == nil {
				m.DestId = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Payload", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNodemessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNodemessage
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Payload = append(m.Payload[:0], dAtA[iNdEx:postIndex]...)
			if m.Payload == nil {
				m.Payload = []byte{}
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxHoldingSeconds", wireType)
			}
			m.MaxHoldingSeconds = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNodemessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxHoldingSeconds |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SrcPubkey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNodemessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNodemessage
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SrcPubkey = append(m.SrcPubkey[:0], dAtA[iNdEx:postIndex]...)
			if m.SrcPubkey == nil {
				m.SrcPubkey = []byte{}
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNodemessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNodemessage
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockHash = append(m.BlockHash[:0], dAtA[iNdEx:postIndex]...)
			if m.BlockHash == nil {
				m.BlockHash = []byte{}
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastSignature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNodemessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNodemessage
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LastSignature = append(m.LastSignature[:0], dAtA[iNdEx:postIndex]...)
			if m.LastSignature == nil {
				m.LastSignature = []byte{}
			}
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SigChainLen", wireType)
			}
			m.SigChainLen = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNodemessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SigChainLen |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipNodemessage(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNodemessage
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipNodemessage(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowNodemessage
			}
			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, ErrIntOverflowNodemessage
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowNodemessage
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			iNdEx += length
			if length < 0 {
				return 0, ErrInvalidLengthNodemessage
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowNodemessage
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipNodemessage(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthNodemessage = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowNodemessage   = fmt.Errorf("proto: integer overflow")
)

func init() { proto.RegisterFile("pb/nodemessage.proto", fileDescriptor_nodemessage_c02ceb21668725d0) }

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