factomEvents.pb.go

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

package eventmessages

import (
	fmt "fmt"
	io "io"
	math "math"
	math_bits "math/bits"

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

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

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

// ====  ENUMS =====
type EventSource int32

const (
	EventSource_LIVE        EventSource = 0
	EventSource_REPLAY_BOOT EventSource = 1
)

var EventSource_name = map[int32]string{
	0: "LIVE",
	1: "REPLAY_BOOT",
}

var EventSource_value = map[string]int32{
	"LIVE":        0,
	"REPLAY_BOOT": 1,
}

func (x EventSource) String() string {
	return proto.EnumName(EventSource_name, int32(x))
}

func (EventSource) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_d6566f2e3579336b, []int{0}
}

type EntityState int32

const (
	EntityState_REQUESTED                    EntityState = 0
	EntityState_ACCEPTED                     EntityState = 1
	EntityState_REJECTED                     EntityState = 2
	EntityState_COMMITTED_TO_DIRECTORY_BLOCK EntityState = 3
)

var EntityState_name = map[int32]string{
	0: "REQUESTED",
	1: "ACCEPTED",
	2: "REJECTED",
	3: "COMMITTED_TO_DIRECTORY_BLOCK",
}

var EntityState_value = map[string]int32{
	"REQUESTED":                    0,
	"ACCEPTED":                     1,
	"REJECTED":                     2,
	"COMMITTED_TO_DIRECTORY_BLOCK": 3,
}

func (x EntityState) String() string {
	return proto.EnumName(EntityState_name, int32(x))
}

func (EntityState) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_d6566f2e3579336b, []int{1}
}

type Level int32

const (
	Level_INFO    Level = 0
	Level_WARNING Level = 1
	Level_ERROR   Level = 2
)

var Level_name = map[int32]string{
	0: "INFO",
	1: "WARNING",
	2: "ERROR",
}

var Level_value = map[string]int32{
	"INFO":    0,
	"WARNING": 1,
	"ERROR":   2,
}

func (x Level) String() string {
	return proto.EnumName(Level_name, int32(x))
}

func (Level) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_d6566f2e3579336b, []int{2}
}

type NodeMessageCode int32

const (
	NodeMessageCode_GENERAL  NodeMessageCode = 0
	NodeMessageCode_STARTED  NodeMessageCode = 1
	NodeMessageCode_SYNCED   NodeMessageCode = 2
	NodeMessageCode_SHUTDOWN NodeMessageCode = 3
)

var NodeMessageCode_name = map[int32]string{
	0: "GENERAL",
	1: "STARTED",
	2: "SYNCED",
	3: "SHUTDOWN",
}

var NodeMessageCode_value = map[string]int32{
	"GENERAL":  0,
	"STARTED":  1,
	"SYNCED":   2,
	"SHUTDOWN": 3,
}

func (x NodeMessageCode) String() string {
	return proto.EnumName(NodeMessageCode_name, int32(x))
}

func (NodeMessageCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_d6566f2e3579336b, []int{3}
}

// ====  ROOT EVENT =====
type FactomEvent struct {
	EventSource     EventSource `protobuf:"varint,1,opt,name=eventSource,proto3,enum=eventmessages.EventSource" json:"eventSource,omitempty"`
	FactomNodeName  string      `protobuf:"bytes,2,opt,name=factomNodeName,proto3" json:"factomNodeName,omitempty"`
	IdentityChainID []byte      `protobuf:"bytes,3,opt,name=identityChainID,proto3" json:"identityChainID,omitempty"`
	// Types that are valid to be assigned to Event:
	//	*FactomEvent_ChainCommit
	//	*FactomEvent_EntryCommit
	//	*FactomEvent_EntryReveal
	//	*FactomEvent_StateChange
	//	*FactomEvent_DirectoryBlockCommit
	//	*FactomEvent_ProcessListEvent
	//	*FactomEvent_NodeMessage
	//	*FactomEvent_DirectoryBlockAnchor
	Event                isFactomEvent_Event `protobuf_oneof:"event"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

var xxx_messageInfo_FactomEvent proto.InternalMessageInfo

type isFactomEvent_Event interface {
	isFactomEvent_Event()
	MarshalTo([]byte) (int, error)
	Size() int
}

type FactomEvent_ChainCommit struct {
	ChainCommit *ChainCommit `protobuf:"bytes,4,opt,name=chainCommit,proto3,oneof" json:"chainCommit,omitempty"`
}
type FactomEvent_EntryCommit struct {
	EntryCommit *EntryCommit `protobuf:"bytes,5,opt,name=entryCommit,proto3,oneof" json:"entryCommit,omitempty"`
}
type FactomEvent_EntryReveal struct {
	EntryReveal *EntryReveal `protobuf:"bytes,6,opt,name=entryReveal,proto3,oneof" json:"entryReveal,omitempty"`
}
type FactomEvent_StateChange struct {
	StateChange *StateChange `protobuf:"bytes,7,opt,name=stateChange,proto3,oneof" json:"stateChange,omitempty"`
}
type FactomEvent_DirectoryBlockCommit struct {
	DirectoryBlockCommit *DirectoryBlockCommit `protobuf:"bytes,8,opt,name=directoryBlockCommit,proto3,oneof" json:"directoryBlockCommit,omitempty"`
}
type FactomEvent_ProcessListEvent struct {
	ProcessListEvent *ProcessListEvent `protobuf:"bytes,9,opt,name=processListEvent,proto3,oneof" json:"processListEvent,omitempty"`
}
type FactomEvent_NodeMessage struct {
	NodeMessage *NodeMessage `protobuf:"bytes,10,opt,name=nodeMessage,proto3,oneof" json:"nodeMessage,omitempty"`
}
type FactomEvent_DirectoryBlockAnchor struct {
	DirectoryBlockAnchor *DirectoryBlockAnchor `protobuf:"bytes,11,opt,name=directoryBlockAnchor,proto3,oneof" json:"directoryBlockAnchor,omitempty"`
}

func (*FactomEvent_ChainCommit) isFactomEvent_Event()          {}
func (*FactomEvent_EntryCommit) isFactomEvent_Event()          {}
func (*FactomEvent_EntryReveal) isFactomEvent_Event()          {}
func (*FactomEvent_StateChange) isFactomEvent_Event()          {}
func (*FactomEvent_DirectoryBlockCommit) isFactomEvent_Event() {}
func (*FactomEvent_ProcessListEvent) isFactomEvent_Event()     {}
func (*FactomEvent_NodeMessage) isFactomEvent_Event()          {}
func (*FactomEvent_DirectoryBlockAnchor) isFactomEvent_Event() {}

func (m *FactomEvent) GetEvent() isFactomEvent_Event {
	if m != nil {
		return m.Event
	}
	return nil
}

func (m *FactomEvent) GetEventSource() EventSource {
	if m != nil {
		return m.EventSource
	}
	return EventSource_LIVE
}

func (m *FactomEvent) GetFactomNodeName() string {
	if m != nil {
		return m.FactomNodeName
	}
	return ""
}

func (m *FactomEvent) GetIdentityChainID() []byte {
	if m != nil {
		return m.IdentityChainID
	}
	return nil
}

func (m *FactomEvent) GetChainCommit() *ChainCommit {
	if x, ok := m.GetEvent().(*FactomEvent_ChainCommit); ok {
		return x.ChainCommit
	}
	return nil
}

func (m *FactomEvent) GetEntryCommit() *EntryCommit {
	if x, ok := m.GetEvent().(*FactomEvent_EntryCommit); ok {
		return x.EntryCommit
	}
	return nil
}

func (m *FactomEvent) GetEntryReveal() *EntryReveal {
	if x, ok := m.GetEvent().(*FactomEvent_EntryReveal); ok {
		return x.EntryReveal
	}
	return nil
}

func (m *FactomEvent) GetStateChange() *StateChange {
	if x, ok := m.GetEvent().(*FactomEvent_StateChange); ok {
		return x.StateChange
	}
	return nil
}

func (m *FactomEvent) GetDirectoryBlockCommit() *DirectoryBlockCommit {
	if x, ok := m.GetEvent().(*FactomEvent_DirectoryBlockCommit); ok {
		return x.DirectoryBlockCommit
	}
	return nil
}

func (m *FactomEvent) GetProcessListEvent() *ProcessListEvent {
	if x, ok := m.GetEvent().(*FactomEvent_ProcessListEvent); ok {
		return x.ProcessListEvent
	}
	return nil
}

func (m *FactomEvent) GetNodeMessage() *NodeMessage {
	if x, ok := m.GetEvent().(*FactomEvent_NodeMessage); ok {
		return x.NodeMessage
	}
	return nil
}

func (m *FactomEvent) GetDirectoryBlockAnchor() *DirectoryBlockAnchor {
	if x, ok := m.GetEvent().(*FactomEvent_DirectoryBlockAnchor); ok {
		return x.DirectoryBlockAnchor
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*FactomEvent) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*FactomEvent_ChainCommit)(nil),
		(*FactomEvent_EntryCommit)(nil),
		(*FactomEvent_EntryReveal)(nil),
		(*FactomEvent_StateChange)(nil),
		(*FactomEvent_DirectoryBlockCommit)(nil),
		(*FactomEvent_ProcessListEvent)(nil),
		(*FactomEvent_NodeMessage)(nil),
		(*FactomEvent_DirectoryBlockAnchor)(nil),
	}
}

// ====  FACTOM EVENT VALUES =====
type ChainCommit struct {
	EntityState          EntityState      `protobuf:"varint,1,opt,name=entityState,proto3,enum=eventmessages.EntityState" json:"entityState,omitempty"`
	ChainIDHash          []byte           `protobuf:"bytes,2,opt,name=chainIDHash,proto3" json:"chainIDHash,omitempty"`
	EntryHash            []byte           `protobuf:"bytes,3,opt,name=entryHash,proto3" json:"entryHash,omitempty"`
	Weld                 []byte           `protobuf:"bytes,4,opt,name=weld,proto3" json:"weld,omitempty"`
	Timestamp            *types.Timestamp `protobuf:"bytes,5,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	Credits              uint32           `protobuf:"varint,6,opt,name=credits,proto3" json:"credits,omitempty"`
	EntryCreditPublicKey []byte           `protobuf:"bytes,7,opt,name=entryCreditPublicKey,proto3" json:"entryCreditPublicKey,omitempty"`
	Signature            []byte           `protobuf:"bytes,8,opt,name=signature,proto3" json:"signature,omitempty"`
	Version              uint32           `protobuf:"varint,9,opt,name=version,proto3" json:"version,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

var xxx_messageInfo_ChainCommit proto.InternalMessageInfo

func (m *ChainCommit) GetEntityState() EntityState {
	if m != nil {
		return m.EntityState
	}
	return EntityState_REQUESTED
}

func (m *ChainCommit) GetChainIDHash() []byte {
	if m != nil {
		return m.ChainIDHash
	}
	return nil
}

func (m *ChainCommit) GetEntryHash() []byte {
	if m != nil {
		return m.EntryHash
	}
	return nil
}

func (m *ChainCommit) GetWeld() []byte {
	if m != nil {
		return m.Weld
	}
	return nil
}

func (m *ChainCommit) GetTimestamp() *types.Timestamp {
	if m != nil {
		return m.Timestamp
	}
	return nil
}

func (m *ChainCommit) GetCredits() uint32 {
	if m != nil {
		return m.Credits
	}
	return 0
}

func (m *ChainCommit) GetEntryCreditPublicKey() []byte {
	if m != nil {
		return m.EntryCreditPublicKey
	}
	return nil
}

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

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

type EntryCommit struct {
	EntityState          EntityState      `protobuf:"varint,1,opt,name=entityState,proto3,enum=eventmessages.EntityState" json:"entityState,omitempty"`
	EntryHash            []byte           `protobuf:"bytes,2,opt,name=entryHash,proto3" json:"entryHash,omitempty"`
	Timestamp            *types.Timestamp `protobuf:"bytes,3,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	Credits              uint32           `protobuf:"varint,4,opt,name=credits,proto3" json:"credits,omitempty"`
	EntryCreditPublicKey []byte           `protobuf:"bytes,5,opt,name=entryCreditPublicKey,proto3" json:"entryCreditPublicKey,omitempty"`
	Signature            []byte           `protobuf:"bytes,6,opt,name=signature,proto3" json:"signature,omitempty"`
	Version              uint32           `protobuf:"varint,7,opt,name=version,proto3" json:"version,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

var xxx_messageInfo_EntryCommit proto.InternalMessageInfo

func (m *EntryCommit) GetEntityState() EntityState {
	if m != nil {
		return m.EntityState
	}
	return EntityState_REQUESTED
}

func (m *EntryCommit) GetEntryHash() []byte {
	if m != nil {
		return m.EntryHash
	}
	return nil
}

func (m *EntryCommit) GetTimestamp() *types.Timestamp {
	if m != nil {
		return m.Timestamp
	}
	return nil
}

func (m *EntryCommit) GetCredits() uint32 {
	if m != nil {
		return m.Credits
	}
	return 0
}

func (m *EntryCommit) GetEntryCreditPublicKey() []byte {
	if m != nil {
		return m.EntryCreditPublicKey
	}
	return nil
}

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

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

type EntryReveal struct {
	EntityState          EntityState      `protobuf:"varint,1,opt,name=entityState,proto3,enum=eventmessages.EntityState" json:"entityState,omitempty"`
	Entry                *EntryBlockEntry `protobuf:"bytes,2,opt,name=entry,proto3" json:"entry,omitempty"`
	Timestamp            *types.Timestamp `protobuf:"bytes,3,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

var xxx_messageInfo_EntryReveal proto.InternalMessageInfo

func (m *EntryReveal) GetEntityState() EntityState {
	if m != nil {
		return m.EntityState
	}
	return EntityState_REQUESTED
}

func (m *EntryReveal) GetEntry() *EntryBlockEntry {
	if m != nil {
		return m.Entry
	}
	return nil
}

func (m *EntryReveal) GetTimestamp() *types.Timestamp {
	if m != nil {
		return m.Timestamp
	}
	return nil
}

type StateChange struct {
	EntityHash           []byte      `protobuf:"bytes,1,opt,name=entityHash,proto3" json:"entityHash,omitempty"`
	EntityState          EntityState `protobuf:"varint,2,opt,name=entityState,proto3,enum=eventmessages.EntityState" json:"entityState,omitempty"`
	BlockHeight          uint32      `protobuf:"varint,3,opt,name=blockHeight,proto3" json:"blockHeight,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

var xxx_messageInfo_StateChange proto.InternalMessageInfo

func (m *StateChange) GetEntityHash() []byte {
	if m != nil {
		return m.EntityHash
	}
	return nil
}

func (m *StateChange) GetEntityState() EntityState {
	if m != nil {
		return m.EntityState
	}
	return EntityState_REQUESTED
}

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

type DirectoryBlockCommit struct {
	DirectoryBlock       *DirectoryBlock    `protobuf:"bytes,1,opt,name=directoryBlock,proto3" json:"directoryBlock,omitempty"`
	AdminBlock           *AdminBlock        `protobuf:"bytes,2,opt,name=adminBlock,proto3" json:"adminBlock,omitempty"`
	FactoidBlock         *FactoidBlock      `protobuf:"bytes,3,opt,name=factoidBlock,proto3" json:"factoidBlock,omitempty"`
	EntryCreditBlock     *EntryCreditBlock  `protobuf:"bytes,4,opt,name=entryCreditBlock,proto3" json:"entryCreditBlock,omitempty"`
	EntryBlocks          []*EntryBlock      `protobuf:"bytes,5,rep,name=entryBlocks,proto3" json:"entryBlocks,omitempty"`
	EntryBlockEntries    []*EntryBlockEntry `protobuf:"bytes,6,rep,name=entryBlockEntries,proto3" json:"entryBlockEntries,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

var xxx_messageInfo_DirectoryBlockCommit proto.InternalMessageInfo

func (m *DirectoryBlockCommit) GetDirectoryBlock() *DirectoryBlock {
	if m != nil {
		return m.DirectoryBlock
	}
	return nil
}

func (m *DirectoryBlockCommit) GetAdminBlock() *AdminBlock {
	if m != nil {
		return m.AdminBlock
	}
	return nil
}

func (m *DirectoryBlockCommit) GetFactoidBlock() *FactoidBlock {
	if m != nil {
		return m.FactoidBlock
	}
	return nil
}

func (m *DirectoryBlockCommit) GetEntryCreditBlock() *EntryCreditBlock {
	if m != nil {
		return m.EntryCreditBlock
	}
	return nil
}

func (m *DirectoryBlockCommit) GetEntryBlocks() []*EntryBlock {
	if m != nil {
		return m.EntryBlocks
	}
	return nil
}

func (m *DirectoryBlockCommit) GetEntryBlockEntries() []*EntryBlockEntry {
	if m != nil {
		return m.EntryBlockEntries
	}
	return nil
}

// ====  ENTRY CREDIT BLOCK =====
type EntryCreditBlock struct {
	Header               *EntryCreditBlockHeader  `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
	Entries              []*EntryCreditBlockEntry `protobuf:"bytes,2,rep,name=entries,proto3" json:"entries,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

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

var xxx_messageInfo_EntryCreditBlock proto.InternalMessageInfo

func (m *EntryCreditBlock) GetHeader() *EntryCreditBlockHeader {
	if m != nil {
		return m.Header
	}
	return nil
}

func (m *EntryCreditBlock) GetEntries() []*EntryCreditBlockEntry {
	if m != nil {
		return m.Entries
	}
	return nil
}

type EntryCreditBlockHeader struct {
	BodyHash             []byte   `protobuf:"bytes,1,opt,name=bodyHash,proto3" json:"bodyHash,omitempty"`
	PreviousHeaderHash   []byte   `protobuf:"bytes,2,opt,name=previousHeaderHash,proto3" json:"previousHeaderHash,omitempty"`
	PreviousFullHash     []byte   `protobuf:"bytes,3,opt,name=previousFullHash,proto3" json:"previousFullHash,omitempty"`
	BlockHeight          uint32   `protobuf:"varint,4,opt,name=blockHeight,proto3" json:"blockHeight,omitempty"`
	ObjectCount          uint64   `protobuf:"varint,5,opt,name=objectCount,proto3" json:"objectCount,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_EntryCreditBlockHeader proto.InternalMessageInfo

func (m *EntryCreditBlockHeader) GetBodyHash() []byte {
	if m != nil {
		return m.BodyHash
	}
	return nil
}

func (m *EntryCreditBlockHeader) GetPreviousHeaderHash() []byte {
	if m != nil {
		return m.PreviousHeaderHash
	}
	return nil
}

func (m *EntryCreditBlockHeader) GetPreviousFullHash() []byte {
	if m != nil {
		return m.PreviousFullHash
	}
	return nil
}

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

func (m *EntryCreditBlockHeader) GetObjectCount() uint64 {
	if m != nil {
		return m.ObjectCount
	}
	return 0
}

type EntryCreditBlockEntry struct {
	// Types that are valid to be assigned to EntryCreditBlockEntry:
	//	*EntryCreditBlockEntry_ChainCommit
	//	*EntryCreditBlockEntry_EntryCommit
	//	*EntryCreditBlockEntry_IncreaseBalance
	//	*EntryCreditBlockEntry_MinuteNumber
	//	*EntryCreditBlockEntry_ServerIndexNumber
	EntryCreditBlockEntry isEntryCreditBlockEntry_EntryCreditBlockEntry `protobuf_oneof:"entryCreditBlockEntry"`
	XXX_NoUnkeyedLiteral  struct{}                                      `json:"-"`
	XXX_unrecognized      []byte                                        `json:"-"`
	XXX_sizecache         int32                                         `json:"-"`
}

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

var xxx_messageInfo_EntryCreditBlockEntry proto.InternalMessageInfo

type isEntryCreditBlockEntry_EntryCreditBlockEntry interface {
	isEntryCreditBlockEntry_EntryCreditBlockEntry()
	MarshalTo([]byte) (int, error)
	Size() int
}

type EntryCreditBlockEntry_ChainCommit struct {
	ChainCommit *ChainCommit `protobuf:"bytes,1,opt,name=chainCommit,proto3,oneof" json:"chainCommit,omitempty"`
}
type EntryCreditBlockEntry_EntryCommit struct {
	EntryCommit *EntryCommit `protobuf:"bytes,2,opt,name=entryCommit,proto3,oneof" json:"entryCommit,omitempty"`
}
type EntryCreditBlockEntry_IncreaseBalance struct {
	IncreaseBalance *IncreaseBalance `protobuf:"bytes,3,opt,name=increaseBalance,proto3,oneof" json:"increaseBalance,omitempty"`
}
type EntryCreditBlockEntry_MinuteNumber struct {
	MinuteNumber *MinuteNumber `protobuf:"bytes,4,opt,name=minuteNumber,proto3,oneof" json:"minuteNumber,omitempty"`
}
type EntryCreditBlockEntry_ServerIndexNumber struct {
	ServerIndexNumber *ServerIndexNumber `protobuf:"bytes,5,opt,name=serverIndexNumber,proto3,oneof" json:"serverIndexNumber,omitempty"`
}

func (*EntryCreditBlockEntry_ChainCommit) isEntryCreditBlockEntry_EntryCreditBlockEntry()       {}
func (*EntryCreditBlockEntry_EntryCommit) isEntryCreditBlockEntry_EntryCreditBlockEntry()       {}
func (*EntryCreditBlockEntry_IncreaseBalance) isEntryCreditBlockEntry_EntryCreditBlockEntry()   {}
func (*EntryCreditBlockEntry_MinuteNumber) isEntryCreditBlockEntry_EntryCreditBlockEntry()      {}
func (*EntryCreditBlockEntry_ServerIndexNumber) isEntryCreditBlockEntry_EntryCreditBlockEntry() {}

func (m *EntryCreditBlockEntry) GetEntryCreditBlockEntry() isEntryCreditBlockEntry_EntryCreditBlockEntry {
	if m != nil {
		return m.EntryCreditBlockEntry
	}
	return nil
}

func (m *EntryCreditBlockEntry) GetChainCommit() *ChainCommit {
	if x, ok := m.GetEntryCreditBlockEntry().(*EntryCreditBlockEntry_ChainCommit); ok {
		return x.ChainCommit
	}
	return nil
}

func (m *EntryCreditBlockEntry) GetEntryCommit() *EntryCommit {
	if x, ok := m.GetEntryCreditBlockEntry().(*EntryCreditBlockEntry_EntryCommit); ok {
		return x.EntryCommit
	}
	return nil
}

func (m *EntryCreditBlockEntry) GetIncreaseBalance() *IncreaseBalance {
	if x, ok := m.GetEntryCreditBlockEntry().(*EntryCreditBlockEntry_IncreaseBalance); ok {
		return x.IncreaseBalance
	}
	return nil
}

func (m *EntryCreditBlockEntry) GetMinuteNumber() *MinuteNumber {
	if x, ok := m.GetEntryCreditBlockEntry().(*EntryCreditBlockEntry_MinuteNumber); ok {
		return x.MinuteNumber
	}
	return nil
}

func (m *EntryCreditBlockEntry) GetServerIndexNumber() *ServerIndexNumber {
	if x, ok := m.GetEntryCreditBlockEntry().(*EntryCreditBlockEntry_ServerIndexNumber); ok {
		return x.ServerIndexNumber
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*EntryCreditBlockEntry) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*EntryCreditBlockEntry_ChainCommit)(nil),
		(*EntryCreditBlockEntry_EntryCommit)(nil),
		(*EntryCreditBlockEntry_IncreaseBalance)(nil),
		(*EntryCreditBlockEntry_MinuteNumber)(nil),
		(*EntryCreditBlockEntry_ServerIndexNumber)(nil),
	}
}

type IncreaseBalance struct {
	EntryCreditPublicKey []byte   `protobuf:"bytes,1,opt,name=entryCreditPublicKey,proto3" json:"entryCreditPublicKey,omitempty"`
	TransactionID        []byte   `protobuf:"bytes,2,opt,name=transactionID,proto3" json:"transactionID,omitempty"`
	Index                uint64   `protobuf:"varint,3,opt,name=index,proto3" json:"index,omitempty"`
	Amount               uint64   `protobuf:"varint,4,opt,name=amount,proto3" json:"amount,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_IncreaseBalance proto.InternalMessageInfo

func (m *IncreaseBalance) GetEntryCreditPublicKey() []byte {
	if m != nil {
		return m.EntryCreditPublicKey
	}
	return nil
}

func (m *IncreaseBalance) GetTransactionID() []byte {
	if m != nil {
		return m.TransactionID
	}
	return nil
}

func (m *IncreaseBalance) GetIndex() uint64 {
	if m != nil {
		return m.Index
	}
	return 0
}

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

type MinuteNumber struct {
	MinuteNumber         uint32   `protobuf:"varint,1,opt,name=minuteNumber,proto3" json:"minuteNumber,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_MinuteNumber proto.InternalMessageInfo

func (m *MinuteNumber) GetMinuteNumber() uint32 {
	if m != nil {
		return m.MinuteNumber
	}
	return 0
}

type ServerIndexNumber struct {
	ServerIndexNumber    uint32   `protobuf:"varint,1,opt,name=serverIndexNumber,proto3" json:"serverIndexNumber,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ServerIndexNumber proto.InternalMessageInfo

func (m *ServerIndexNumber) GetServerIndexNumber() uint32 {
	if m != nil {
		return m.ServerIndexNumber
	}
	return 0
}

type NodeMessage struct {
	MessageCode          NodeMessageCode `protobuf:"varint,1,opt,name=messageCode,proto3,enum=eventmessages.NodeMessageCode" json:"messageCode,omitempty"`
	Level                Level           `protobuf:"varint,2,opt,name=level,proto3,enum=eventmessages.Level" json:"level,omitempty"`
	MessageText          string          `protobuf:"bytes,3,opt,name=messageText,proto3" json:"messageText,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

var xxx_messageInfo_NodeMessage proto.InternalMessageInfo

func (m *NodeMessage) GetMessageCode() NodeMessageCode {
	if m != nil {
		return m.MessageCode
	}
	return NodeMessageCode_GENERAL
}

func (m *NodeMessage) GetLevel() Level {
	if m != nil {
		return m.Level
	}
	return Level_INFO
}

func (m *NodeMessage) GetMessageText() string {
	if m != nil {
		return m.MessageText
	}
	return ""
}

// ====  PROCESS LIST EVENTS =====
type ProcessListEvent struct {
	// Types that are valid to be assigned to ProcessListEvent:
	//	*ProcessListEvent_NewBlockEvent
	//	*ProcessListEvent_NewMinuteEvent
	ProcessListEvent     isProcessListEvent_ProcessListEvent `protobuf_oneof:"processListEvent"`
	XXX_NoUnkeyedLiteral struct{}                            `json:"-"`
	XXX_unrecognized     []byte                              `json:"-"`
	XXX_sizecache        int32                               `json:"-"`
}

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

var xxx_messageInfo_ProcessListEvent proto.InternalMessageInfo

type isProcessListEvent_ProcessListEvent interface {
	isProcessListEvent_ProcessListEvent()
	MarshalTo([]byte) (int, error)
	Size() int
}

type ProcessListEvent_NewBlockEvent struct {
	NewBlockEvent *NewBlockEvent `protobuf:"bytes,1,opt,name=newBlockEvent,proto3,oneof" json:"newBlockEvent,omitempty"`
}
type ProcessListEvent_NewMinuteEvent struct {
	NewMinuteEvent *NewMinuteEvent `protobuf:"bytes,2,opt,name=newMinuteEvent,proto3,oneof" json:"newMinuteEvent,omitempty"`
}

func (*ProcessListEvent_NewBlockEvent) isProcessListEvent_ProcessListEvent()  {}
func (*ProcessListEvent_NewMinuteEvent) isProcessListEvent_ProcessListEvent() {}

func (m *ProcessListEvent) GetProcessListEvent() isProcessListEvent_ProcessListEvent {
	if m != nil {
		return m.ProcessListEvent
	}
	return nil
}

func (m *ProcessListEvent) GetNewBlockEvent() *NewBlockEvent {
	if x, ok := m.GetProcessListEvent().(*ProcessListEvent_NewBlockEvent); ok {
		return x.NewBlockEvent
	}
	return nil
}

func (m *ProcessListEvent) GetNewMinuteEvent() *NewMinuteEvent {
	if x, ok := m.GetProcessListEvent().(*ProcessListEvent_NewMinuteEvent); ok {
		return x.NewMinuteEvent
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ProcessListEvent) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ProcessListEvent_NewBlockEvent)(nil),
		(*ProcessListEvent_NewMinuteEvent)(nil),
	}
}

type NewBlockEvent struct {
	NewBlockHeight       uint32   `protobuf:"varint,1,opt,name=newBlockHeight,proto3" json:"newBlockHeight,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_NewBlockEvent proto.InternalMessageInfo

func (m *NewBlockEvent) GetNewBlockHeight() uint32 {
	if m != nil {
		return m.NewBlockHeight
	}
	return 0
}

type NewMinuteEvent struct {
	NewMinute            uint32   `protobuf:"varint,1,opt,name=newMinute,proto3" json:"newMinute,omitempty"`
	BlockHeight          uint32   `protobuf:"varint,2,opt,name=blockHeight,proto3" json:"blockHeight,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_NewMinuteEvent proto.InternalMessageInfo

func (m *NewMinuteEvent) GetNewMinute() uint32 {
	if m != nil {
		return m.NewMinute
	}
	return 0
}

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

func init() {
	proto.RegisterEnum("eventmessages.EventSource", EventSource_name, EventSource_value)
	proto.RegisterEnum("eventmessages.EntityState", EntityState_name, EntityState_value)
	proto.RegisterEnum("eventmessages.Level", Level_name, Level_value)
	proto.RegisterEnum("eventmessages.NodeMessageCode", NodeMessageCode_name, NodeMessageCode_value)
	proto.RegisterType((*FactomEvent)(nil), "eventmessages.FactomEvent")
	proto.RegisterType((*ChainCommit)(nil), "eventmessages.ChainCommit")
	proto.RegisterType((*EntryCommit)(nil), "eventmessages.EntryCommit")
	proto.RegisterType((*EntryReveal)(nil), "eventmessages.EntryReveal")
	proto.RegisterType((*StateChange)(nil), "eventmessages.StateChange")
	proto.RegisterType((*DirectoryBlockCommit)(nil), "eventmessages.DirectoryBlockCommit")
	proto.RegisterType((*EntryCreditBlock)(nil), "eventmessages.EntryCreditBlock")
	proto.RegisterType((*EntryCreditBlockHeader)(nil), "eventmessages.EntryCreditBlockHeader")
	proto.RegisterType((*EntryCreditBlockEntry)(nil), "eventmessages.EntryCreditBlockEntry")
	proto.RegisterType((*IncreaseBalance)(nil), "eventmessages.IncreaseBalance")
	proto.RegisterType((*MinuteNumber)(nil), "eventmessages.MinuteNumber")
	proto.RegisterType((*ServerIndexNumber)(nil), "eventmessages.ServerIndexNumber")
	proto.RegisterType((*NodeMessage)(nil), "eventmessages.NodeMessage")
	proto.RegisterType((*ProcessListEvent)(nil), "eventmessages.ProcessListEvent")
	proto.RegisterType((*NewBlockEvent)(nil), "eventmessages.NewBlockEvent")
	proto.RegisterType((*NewMinuteEvent)(nil), "eventmessages.NewMinuteEvent")
}

func init() { proto.RegisterFile("eventmessages/factomEvents.proto", fileDescriptor_d6566f2e3579336b) }

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

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

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

func (m *FactomEvent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Event != nil {
		{
			size := m.Event.Size()
			i -= size
			if _, err := m.Event.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if len(m.IdentityChainID) > 0 {
		i -= len(m.IdentityChainID)
		copy(dAtA[i:], m.IdentityChainID)
		i = encodeVarintFactomEvents(dAtA, i, uint64(len(m.IdentityChainID)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.FactomNodeName) > 0 {
		i -= len(m.FactomNodeName)
		copy(dAtA[i:], m.FactomNodeName)
		i = encodeVarintFactomEvents(dAtA, i, uint64(len(m.FactomNodeName)))
		i--
		dAtA[i] = 0x12
	}
	if m.EventSource != 0 {
		i = encodeVarintFactomEvents(dAtA, i, uint64(m.EventSource))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *FactomEvent_ChainCommit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ChainCommit != nil {
		{
			size, err := m.ChainCommit.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintFactomEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func (m *FactomEvent_EntryCommit) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FactomEvent_EntryCommit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.EntryCommit != nil {
		{
			size, err := m.EntryCommit.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintFactomEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	return len(dAtA) - i, nil
}
func (m *FactomEvent_EntryReveal) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FactomEvent_EntryReveal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.EntryReveal != nil {
		{
			size, err := m.EntryReveal.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintFactomEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	return len(dAtA) - i, nil
}
func (m *FactomEvent_StateChange) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FactomEvent_StateChange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.StateChange != nil {
		{
			size, err := m.StateChange.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintFactomEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	return len(dAtA) - i, nil
}
func (m *FactomEvent_DirectoryBlockCommit) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FactomEvent_DirectoryBlockCommit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.DirectoryBlockCommit != nil {
		{
			size, err := m.DirectoryBlockCommit.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintFactomEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	return len(dAtA) - i, nil
}
func (m *FactomEvent_ProcessListEvent) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FactomEvent_ProcessListEvent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ProcessListEvent != nil {
		{
			size, err := m.ProcessListEvent.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintFactomEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	return len(dAtA) - i, nil
}
func (m *FactomEvent_NodeMessage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FactomEvent_NodeMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.NodeMessage != nil {
		{
			size, err := m.NodeMessage.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintFactomEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	return len(dAtA) - i, nil
}
func (m *FactomEvent_DirectoryBlockAnchor) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FactomEvent_DirectoryBlockAnchor) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.DirectoryBlockAnchor != nil {
		{
			size, err := m.DirectoryBlockAnchor.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintFactomEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x5a
	}
	return len(dAtA) - i, nil
}
func (m *ChainCommit) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *ChainCommit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Version != 0 {
		i = encodeVarintFactomEvents(dAtA, i, uint64(m.Version))
		i--
		dAtA[i] = 0x48
	}
	if len(m.Signature) > 0 {
		i -= len(m.Signature)
		copy(dAtA[i:], m.Signature)
		i = encodeVarintFactomEvents(dAtA, i, uint64(len(m.Signature)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.EntryCreditPublicKey) > 0 {
		i -= len(m.EntryCreditPublicKey)
		copy(dAtA[i:], m.EntryCreditPublicKey)
		i = encodeVarintFactomEvents(dAtA, i, uint64(len(m.EntryCreditPublicKey)))
		i--
		dAtA[i] = 0x3a
	}
	if m.Credits != 0 {
		i = encodeVarintFactomEvents(dAtA, i, uint64(m.Credits))
		i--
		dAtA[i] = 0x30
	}
	if m.Timestamp != nil {
		{
			size, err := m.Timestamp.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintFactomEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Weld) > 0 {
		i -= len(m.Weld)
		copy(dAtA[i:], m.Weld)
		i = encodeVarintFactomEvents(dAtA, i, uint64(len(m.Weld)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.EntryHash) > 0 {
		i -= len(m.EntryHash)
		copy(dAtA[i:], m.EntryHash)
		i = encodeVarintFactomEvents(dAtA, i, uint64(len(m.EntryHash)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ChainIDHash) > 0 {
		i -= len(m.ChainIDHash)
		copy(dAtA[i:], m.ChainIDHash)
		i = encodeVarintFactomEvents(dAtA, i, uint64(len(m.ChainIDHash)))
		i--
		dAtA[i] = 0x12
	}
	if m.EntityState != 0 {
		i = encodeVarintFactomEvents(dAtA, i, uint64(m.EntityState))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *EntryCommit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Version != 0 {
		i = encodeVarintFactomEvents(dAtA, i, uint64(m.Version))
		i--
		dAtA[i] = 0x38
	}
	if len(m.Signature) > 0 {
		i -= len(m.Signature)
		copy(dAtA[i:], m.Signature)
		i = encodeVarintFactomEvents(dAtA, i, uint64(len(m.Signature)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.EntryCreditPublicKey) > 0 {
		i -= len(m.EntryCreditPublicKey)
		copy(dAtA[i:], m.EntryCreditPublicKey)
		i = encodeVarintFactomEvents(dAtA, i, uint64(len(m.EntryCreditPublicKey)))
		i--
		dAtA[i] = 0x2a
	}
	if m.Credits != 0 {
		i = encodeVarintFactomEvents(dAtA, i, uint64(m.Credits))
		i--
		dAtA[i] = 0x20
	}
	if m.Timestamp != nil {
		{
			size, err := m.Timestamp.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintFactomEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.EntryHash) > 0 {
		i -= len(m.EntryHash)
		copy(dAtA[i:], m.EntryHash)
		i = encodeVarintFactomEvents(dAtA, i, uint64(len(m.EntryHash)))
		i--
		dAtA[i] = 0x12
	}
	if m.EntityState != 0 {
		i = encodeVarintFactomEvents(dAtA, i, uint64(m.EntityState))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *EntryReveal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Timestamp != nil {
		{
			size, err := m.Timestamp.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintFactomEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Entry != nil {
		{
			size, err := m.Entry.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintFactomEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.EntityState != 0 {
		i = encodeVarintFactomEvents(dAtA, i, uint64(m.EntityState))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *StateChange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.BlockHeight != 0 {
		i = encodeVarintFactomEvents(dAtA, i, uint64(m.BlockHeight))
		i--
		dAtA[i] = 0x18
	}
	if m.EntityState != 0 {
		i = encodeVarintFactomEvents(dAtA, i, uint64(m.EntityState))
		i--
		dAtA[i] = 0x10
	}
	if len(m.EntityHash) > 0 {
		i -= len(m.EntityHash)
		copy(dAtA[i:], m.EntityHash)
		i = encodeVarintFactomEvents(dAtA, i, uint64(len(m.EntityHash)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *DirectoryBlockCommit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.EntryBlockEntries) > 0 {
		for iNdEx := len(m.EntryBlockEntries) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.EntryBlockEntries[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintFactomEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.EntryBlocks) > 0 {
		for iNdEx := len(m.EntryBlocks) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.EntryBlocks[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintFactomEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if m.EntryCreditBlock != nil {
		{
			size, err := m.EntryCreditBlock.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintFactomEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.FactoidBlock != nil {
		{
			size, err := m.FactoidBlock.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintFactomEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.AdminBlock != nil {
		{
			size, err := m.AdminBlock.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintFactomEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.DirectoryBlock != nil {
		{
			size, err := m.DirectoryBlock.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintFactomEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *EntryCreditBlockHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.ObjectCount != 0 {
		i = encodeVarintFactomEvents(dAtA, i, uint64(m.ObjectCount))
		i--
		dAtA[i] = 0x28
	}
	if m.BlockHeight != 0 {
		i = encodeVarintFactomEvents(dAtA, i, uint64(m.BlockHeight))
		i--
		dAtA[i] = 0x20
	}
	if len(m.PreviousFullHash) > 0 {
		i -= len(m.PreviousFullHash)
		copy(dAtA[i:], m.PreviousFullHash)
		i = encodeVarintFactomEvents(dAtA, i, uint64(len(m.PreviousFullHash)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.PreviousHeaderHash) > 0 {
		i -= len(m.PreviousHeaderHash)
		copy(dAtA[i:], m.PreviousHeaderHash)
		i = encodeVarintFactomEvents(dAtA, i, uint64(len(m.PreviousHeaderHash)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.BodyHash) > 0 {
		i -= len(m.BodyHash)
		copy(dAtA[i:], m.BodyHash)
		i = encodeVarintFactomEvents(dAtA, i, uint64(len(m.BodyHash)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

func (m *EntryCreditBlockEntry_ChainCommit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ChainCommit != nil {
		{
			size, err := m.ChainCommit.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintFactomEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *EntryCreditBlockEntry_EntryCommit) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EntryCreditBlockEntry_EntryCommit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.EntryCommit != nil {
		{
			size, err := m.EntryCommit.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintFactomEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *EntryCreditBlockEntry_IncreaseBalance) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EntryCreditBlockEntry_IncreaseBalance) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.IncreaseBalance != nil {
		{
			size, err := m.IncreaseBalance.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintFactomEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *EntryCreditBlockEntry_MinuteNumber) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EntryCreditBlockEntry_MinuteNumber) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.MinuteNumber != nil {
		{
			size, err := m.MinuteNumber.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintFactomEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func (m *EntryCreditBlockEntry_ServerIndexNumber) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EntryCreditBlockEntry_ServerIndexNumber) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ServerIndexNumber != nil {
		{
			size, err := m.ServerIndexNumber.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintFactomEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	return len(dAtA) - i, nil
}
func (m *IncreaseBalance) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *IncreaseBalance) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Amount != 0 {
		i = encodeVarintFactomEvents(dAtA, i, uint64(m.Amount))
		i--
		dAtA[i] = 0x20
	}
	if m.Index != 0 {
		i = encodeVarintFactomEvents(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x18
	}
	if len(m.TransactionID) > 0 {
		i -= len(m.TransactionID)
		copy(dAtA[i:], m.TransactionID)
		i = encodeVarintFactomEvents(dAtA, i, uint64(len(m.TransactionID)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.EntryCreditPublicKey) > 0 {
		i -= len(m.EntryCreditPublicKey)
		copy(dAtA[i:], m.EntryCreditPublicKey)
		i = encodeVarintFactomEvents(dAtA, i, uint64(len(m.EntryCreditPublicKey)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

func (m *NodeMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.MessageText) > 0 {
		i -= len(m.MessageText)
		copy(dAtA[i:], m.MessageText)
		i = encodeVarintFactomEvents(dAtA, i, uint64(len(m.MessageText)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Level != 0 {
		i = encodeVarintFactomEvents(dAtA, i, uint64(m.Level))
		i--
		dAtA[i] = 0x10
	}
	if m.MessageCode != 0 {
		i = encodeVarintFactomEvents(dAtA, i, uint64(m.MessageCode))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

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

func (m *ProcessListEvent_NewBlockEvent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.NewBlockEvent != nil {
		{
			size, err := m.NewBlockEvent.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintFactomEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *ProcessListEvent_NewMinuteEvent) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ProcessListEvent_NewMinuteEvent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.NewMinuteEvent != nil {
		{
			size, err := m.NewMinuteEvent.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintFactomEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *NewBlockEvent) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *NewBlockEvent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.NewBlockHeight != 0 {
		i = encodeVarintFactomEvents(dAtA, i, uint64(m.NewBlockHeight))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *NewMinuteEvent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.BlockHeight != 0 {
		i = encodeVarintFactomEvents(dAtA, i, uint64(m.BlockHeight))
		i--
		dAtA[i] = 0x10
	}
	if m.NewMinute != 0 {
		i = encodeVarintFactomEvents(dAtA, i, uint64(m.NewMinute))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintFactomEvents(dAtA []byte, offset int, v uint64) int {
	offset -= sovFactomEvents(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *FactomEvent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.EventSource != 0 {
		n += 1 + sovFactomEvents(uint64(m.EventSource))
	}
	l = len(m.FactomNodeName)
	if l > 0 {
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	l = len(m.IdentityChainID)
	if l > 0 {
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	if m.Event != nil {
		n += m.Event.Size()
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *FactomEvent_ChainCommit) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChainCommit != nil {
		l = m.ChainCommit.Size()
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	return n
}
func (m *FactomEvent_EntryCommit) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.EntryCommit != nil {
		l = m.EntryCommit.Size()
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	return n
}
func (m *FactomEvent_EntryReveal) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.EntryReveal != nil {
		l = m.EntryReveal.Size()
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	return n
}
func (m *FactomEvent_StateChange) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StateChange != nil {
		l = m.StateChange.Size()
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	return n
}
func (m *FactomEvent_DirectoryBlockCommit) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.DirectoryBlockCommit != nil {
		l = m.DirectoryBlockCommit.Size()
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	return n
}
func (m *FactomEvent_ProcessListEvent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ProcessListEvent != nil {
		l = m.ProcessListEvent.Size()
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	return n
}
func (m *FactomEvent_NodeMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NodeMessage != nil {
		l = m.NodeMessage.Size()
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	return n
}
func (m *FactomEvent_DirectoryBlockAnchor) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.DirectoryBlockAnchor != nil {
		l = m.DirectoryBlockAnchor.Size()
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	return n
}
func (m *ChainCommit) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.EntityState != 0 {
		n += 1 + sovFactomEvents(uint64(m.EntityState))
	}
	l = len(m.ChainIDHash)
	if l > 0 {
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	l = len(m.EntryHash)
	if l > 0 {
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	l = len(m.Weld)
	if l > 0 {
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	if m.Timestamp != nil {
		l = m.Timestamp.Size()
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	if m.Credits != 0 {
		n += 1 + sovFactomEvents(uint64(m.Credits))
	}
	l = len(m.EntryCreditPublicKey)
	if l > 0 {
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	l = len(m.Signature)
	if l > 0 {
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	if m.Version != 0 {
		n += 1 + sovFactomEvents(uint64(m.Version))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *EntryCommit) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.EntityState != 0 {
		n += 1 + sovFactomEvents(uint64(m.EntityState))
	}
	l = len(m.EntryHash)
	if l > 0 {
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	if m.Timestamp != nil {
		l = m.Timestamp.Size()
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	if m.Credits != 0 {
		n += 1 + sovFactomEvents(uint64(m.Credits))
	}
	l = len(m.EntryCreditPublicKey)
	if l > 0 {
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	l = len(m.Signature)
	if l > 0 {
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	if m.Version != 0 {
		n += 1 + sovFactomEvents(uint64(m.Version))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *EntryReveal) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.EntityState != 0 {
		n += 1 + sovFactomEvents(uint64(m.EntityState))
	}
	if m.Entry != nil {
		l = m.Entry.Size()
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	if m.Timestamp != nil {
		l = m.Timestamp.Size()
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *StateChange) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.EntityHash)
	if l > 0 {
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	if m.EntityState != 0 {
		n += 1 + sovFactomEvents(uint64(m.EntityState))
	}
	if m.BlockHeight != 0 {
		n += 1 + sovFactomEvents(uint64(m.BlockHeight))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DirectoryBlockCommit) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.DirectoryBlock != nil {
		l = m.DirectoryBlock.Size()
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	if m.AdminBlock != nil {
		l = m.AdminBlock.Size()
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	if m.FactoidBlock != nil {
		l = m.FactoidBlock.Size()
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	if m.EntryCreditBlock != nil {
		l = m.EntryCreditBlock.Size()
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	if len(m.EntryBlocks) > 0 {
		for _, e := range m.EntryBlocks {
			l = e.Size()
			n += 1 + l + sovFactomEvents(uint64(l))
		}
	}
	if len(m.EntryBlockEntries) > 0 {
		for _, e := range m.EntryBlockEntries {
			l = e.Size()
			n += 1 + l + sovFactomEvents(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *EntryCreditBlock) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Header != nil {
		l = m.Header.Size()
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	if len(m.Entries) > 0 {
		for _, e := range m.Entries {
			l = e.Size()
			n += 1 + l + sovFactomEvents(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *EntryCreditBlockHeader) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.BodyHash)
	if l > 0 {
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	l = len(m.PreviousHeaderHash)
	if l > 0 {
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	l = len(m.PreviousFullHash)
	if l > 0 {
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	if m.BlockHeight != 0 {
		n += 1 + sovFactomEvents(uint64(m.BlockHeight))
	}
	if m.ObjectCount != 0 {
		n += 1 + sovFactomEvents(uint64(m.ObjectCount))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *EntryCreditBlockEntry) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.EntryCreditBlockEntry != nil {
		n += m.EntryCreditBlockEntry.Size()
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *EntryCreditBlockEntry_ChainCommit) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChainCommit != nil {
		l = m.ChainCommit.Size()
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	return n
}
func (m *EntryCreditBlockEntry_EntryCommit) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.EntryCommit != nil {
		l = m.EntryCommit.Size()
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	return n
}
func (m *EntryCreditBlockEntry_IncreaseBalance) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.IncreaseBalance != nil {
		l = m.IncreaseBalance.Size()
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	return n
}
func (m *EntryCreditBlockEntry_MinuteNumber) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MinuteNumber != nil {
		l = m.MinuteNumber.Size()
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	return n
}
func (m *EntryCreditBlockEntry_ServerIndexNumber) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ServerIndexNumber != nil {
		l = m.ServerIndexNumber.Size()
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	return n
}
func (m *IncreaseBalance) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.EntryCreditPublicKey)
	if l > 0 {
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	l = len(m.TransactionID)
	if l > 0 {
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	if m.Index != 0 {
		n += 1 + sovFactomEvents(uint64(m.Index))
	}
	if m.Amount != 0 {
		n += 1 + sovFactomEvents(uint64(m.Amount))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *MinuteNumber) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MinuteNumber != 0 {
		n += 1 + sovFactomEvents(uint64(m.MinuteNumber))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ServerIndexNumber) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ServerIndexNumber != 0 {
		n += 1 + sovFactomEvents(uint64(m.ServerIndexNumber))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *NodeMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MessageCode != 0 {
		n += 1 + sovFactomEvents(uint64(m.MessageCode))
	}
	if m.Level != 0 {
		n += 1 + sovFactomEvents(uint64(m.Level))
	}
	l = len(m.MessageText)
	if l > 0 {
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ProcessListEvent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ProcessListEvent != nil {
		n += m.ProcessListEvent.Size()
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ProcessListEvent_NewBlockEvent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NewBlockEvent != nil {
		l = m.NewBlockEvent.Size()
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	return n
}
func (m *ProcessListEvent_NewMinuteEvent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NewMinuteEvent != nil {
		l = m.NewMinuteEvent.Size()
		n += 1 + l + sovFactomEvents(uint64(l))
	}
	return n
}
func (m *NewBlockEvent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NewBlockHeight != 0 {
		n += 1 + sovFactomEvents(uint64(m.NewBlockHeight))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *NewMinuteEvent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NewMinute != 0 {
		n += 1 + sovFactomEvents(uint64(m.NewMinute))
	}
	if m.BlockHeight != 0 {
		n += 1 + sovFactomEvents(uint64(m.BlockHeight))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovFactomEvents(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozFactomEvents(x uint64) (n int) {
	return sovFactomEvents(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *FactomEvent) 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 ErrIntOverflowFactomEvents
			}
			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: FactomEvent: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FactomEvent: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EventSource", wireType)
			}
			m.EventSource = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EventSource |= EventSource(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FactomNodeName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				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 ErrInvalidLengthFactomEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FactomNodeName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IdentityChainID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthFactomEvents
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IdentityChainID = append(m.IdentityChainID[:0], dAtA[iNdEx:postIndex]...)
			if m.IdentityChainID == nil {
				m.IdentityChainID = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChainCommit", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFactomEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ChainCommit{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Event = &FactomEvent_ChainCommit{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EntryCommit", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFactomEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EntryCommit{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Event = &FactomEvent_EntryCommit{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EntryReveal", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFactomEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EntryReveal{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Event = &FactomEvent_EntryReveal{v}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StateChange", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFactomEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &StateChange{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Event = &FactomEvent_StateChange{v}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DirectoryBlockCommit", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFactomEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &DirectoryBlockCommit{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Event = &FactomEvent_DirectoryBlockCommit{v}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProcessListEvent", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFactomEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ProcessListEvent{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Event = &FactomEvent_ProcessListEvent{v}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeMessage", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFactomEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &NodeMessage{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Event = &FactomEvent_NodeMessage{v}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DirectoryBlockAnchor", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFactomEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &DirectoryBlockAnchor{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Event = &FactomEvent_DirectoryBlockAnchor{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFactomEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChainCommit) 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 ErrIntOverflowFactomEvents
			}
			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: ChainCommit: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ChainCommit: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EntityState", wireType)
			}
			m.EntityState = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EntityState |= EntityState(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChainIDHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthFactomEvents
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChainIDHash = append(m.ChainIDHash[:0], dAtA[iNdEx:postIndex]...)
			if m.ChainIDHash == nil {
				m.ChainIDHash = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EntryHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthFactomEvents
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EntryHash = append(m.EntryHash[:0], dAtA[iNdEx:postIndex]...)
			if m.EntryHash == nil {
				m.EntryHash = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Weld", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthFactomEvents
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Weld = append(m.Weld[:0], dAtA[iNdEx:postIndex]...)
			if m.Weld == nil {
				m.Weld = []byte{}
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFactomEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Timestamp == nil {
				m.Timestamp = &types.Timestamp{}
			}
			if err := m.Timestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Credits", wireType)
			}
			m.Credits = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Credits |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EntryCreditPublicKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthFactomEvents
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EntryCreditPublicKey = append(m.EntryCreditPublicKey[:0], dAtA[iNdEx:postIndex]...)
			if m.EntryCreditPublicKey == nil {
				m.EntryCreditPublicKey = []byte{}
			}
			iNdEx = postIndex
		case 8:
			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 ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthFactomEvents
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...)
			if m.Signature == nil {
				m.Signature = []byte{}
			}
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			m.Version = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Version |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipFactomEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EntryCommit) 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 ErrIntOverflowFactomEvents
			}
			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: EntryCommit: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EntryCommit: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EntityState", wireType)
			}
			m.EntityState = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EntityState |= EntityState(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EntryHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthFactomEvents
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EntryHash = append(m.EntryHash[:0], dAtA[iNdEx:postIndex]...)
			if m.EntryHash == nil {
				m.EntryHash = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFactomEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Timestamp == nil {
				m.Timestamp = &types.Timestamp{}
			}
			if err := m.Timestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Credits", wireType)
			}
			m.Credits = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Credits |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EntryCreditPublicKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthFactomEvents
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EntryCreditPublicKey = append(m.EntryCreditPublicKey[:0], dAtA[iNdEx:postIndex]...)
			if m.EntryCreditPublicKey == nil {
				m.EntryCreditPublicKey = []byte{}
			}
			iNdEx = postIndex
		case 6:
			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 ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthFactomEvents
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...)
			if m.Signature == nil {
				m.Signature = []byte{}
			}
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			m.Version = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Version |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipFactomEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DirectoryBlockCommit) 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 ErrIntOverflowFactomEvents
			}
			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: DirectoryBlockCommit: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DirectoryBlockCommit: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DirectoryBlock", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFactomEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DirectoryBlock == nil {
				m.DirectoryBlock = &DirectoryBlock{}
			}
			if err := m.DirectoryBlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AdminBlock", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFactomEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.AdminBlock == nil {
				m.AdminBlock = &AdminBlock{}
			}
			if err := m.AdminBlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FactoidBlock", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFactomEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FactoidBlock == nil {
				m.FactoidBlock = &FactoidBlock{}
			}
			if err := m.FactoidBlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EntryCreditBlock", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFactomEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.EntryCreditBlock == nil {
				m.EntryCreditBlock = &EntryCreditBlock{}
			}
			if err := m.EntryCreditBlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EntryBlocks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFactomEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EntryBlocks = append(m.EntryBlocks, &EntryBlock{})
			if err := m.EntryBlocks[len(m.EntryBlocks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EntryBlockEntries", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFactomEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EntryBlockEntries = append(m.EntryBlockEntries, &EntryBlockEntry{})
			if err := m.EntryBlockEntries[len(m.EntryBlockEntries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFactomEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EntryCreditBlockHeader) 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 ErrIntOverflowFactomEvents
			}
			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: EntryCreditBlockHeader: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EntryCreditBlockHeader: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BodyHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthFactomEvents
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BodyHash = append(m.BodyHash[:0], dAtA[iNdEx:postIndex]...)
			if m.BodyHash == nil {
				m.BodyHash = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PreviousHeaderHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthFactomEvents
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PreviousHeaderHash = append(m.PreviousHeaderHash[:0], dAtA[iNdEx:postIndex]...)
			if m.PreviousHeaderHash == nil {
				m.PreviousHeaderHash = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PreviousFullHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthFactomEvents
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PreviousFullHash = append(m.PreviousFullHash[:0], dAtA[iNdEx:postIndex]...)
			if m.PreviousFullHash == nil {
				m.PreviousFullHash = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
			}
			m.BlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockHeight |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectCount", wireType)
			}
			m.ObjectCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ObjectCount |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipFactomEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EntryCreditBlockEntry) 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 ErrIntOverflowFactomEvents
			}
			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: EntryCreditBlockEntry: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EntryCreditBlockEntry: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChainCommit", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFactomEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ChainCommit{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.EntryCreditBlockEntry = &EntryCreditBlockEntry_ChainCommit{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EntryCommit", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFactomEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EntryCommit{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.EntryCreditBlockEntry = &EntryCreditBlockEntry_EntryCommit{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IncreaseBalance", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFactomEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &IncreaseBalance{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.EntryCreditBlockEntry = &EntryCreditBlockEntry_IncreaseBalance{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinuteNumber", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFactomEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &MinuteNumber{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.EntryCreditBlockEntry = &EntryCreditBlockEntry_MinuteNumber{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServerIndexNumber", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFactomEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ServerIndexNumber{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.EntryCreditBlockEntry = &EntryCreditBlockEntry_ServerIndexNumber{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFactomEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthFactomEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

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

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipFactomEvents(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, ErrIntOverflowFactomEvents
			}
			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, ErrIntOverflowFactomEvents
				}
				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, ErrIntOverflowFactomEvents
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthFactomEvents
			}
			iNdEx += length
			if iNdEx < 0 {
				return 0, ErrInvalidLengthFactomEvents
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowFactomEvents
					}
					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 := skipFactomEvents(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
				if iNdEx < 0 {
					return 0, ErrInvalidLengthFactomEvents
				}
			}
			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 (
	ErrInvalidLengthFactomEvents = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowFactomEvents   = fmt.Errorf("proto: integer overflow")
)