github.com/annchain/OG@v0.0.9/og/protocol/ogmessage/archive/messages_gen.go

package archive

// Code generated by github.com/tinylib/msgp DO NOT EDIT.

import (
	"github.com/annchain/OG/arefactor/og/types"
	"github.com/annchain/OG/og/protocol/dagmessage"
	"github.com/tinylib/msgp/msgp"
)

// DecodeMsg implements msgp.Decodable
func (z *MessageAnnsensus) DecodeMsg(dc *msgp.Reader) (err error) {
	var zb0001 uint32
	zb0001, err = dc.ReadArrayHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 2 {
		err = msgp.ArrayError{Wanted: 2, Got: zb0001}
		return
	}
	err = z.InnerMessageType.DecodeMsg(dc)
	if err != nil {
		err = msgp.WrapError(err, "InnerMessageType")
		return
	}
	z.InnerMessage, err = dc.ReadBytes(z.InnerMessage)
	if err != nil {
		err = msgp.WrapError(err, "InnerMessage")
		return
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *MessageAnnsensus) EncodeMsg(en *msgp.Writer) (err error) {
	// array header, size 2
	err = en.Append(0x92)
	if err != nil {
		return
	}
	err = z.InnerMessageType.EncodeMsg(en)
	if err != nil {
		err = msgp.WrapError(err, "InnerMessageType")
		return
	}
	err = en.WriteBytes(z.InnerMessage)
	if err != nil {
		err = msgp.WrapError(err, "InnerMessage")
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *MessageAnnsensus) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// array header, size 2
	o = append(o, 0x92)
	o, err = z.InnerMessageType.MarshalMsg(o)
	if err != nil {
		err = msgp.WrapError(err, "InnerMessageType")
		return
	}
	o = msgp.AppendBytes(o, z.InnerMessage)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *MessageAnnsensus) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadArrayHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 2 {
		err = msgp.ArrayError{Wanted: 2, Got: zb0001}
		return
	}
	bts, err = z.InnerMessageType.UnmarshalMsg(bts)
	if err != nil {
		err = msgp.WrapError(err, "InnerMessageType")
		return
	}
	z.InnerMessage, bts, err = msgp.ReadBytesBytes(bts, z.InnerMessage)
	if err != nil {
		err = msgp.WrapError(err, "InnerMessage")
		return
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *MessageAnnsensus) Msgsize() (s int) {
	s = 1 + z.InnerMessageType.Msgsize() + msgp.BytesPrefixSize + len(z.InnerMessage)
	return
}

// DecodeMsg implements msgp.Decodable
func (z *MessageBodiesRequest) DecodeMsg(dc *msgp.Reader) (err error) {
	var zb0001 uint32
	zb0001, err = dc.ReadArrayHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 2 {
		err = msgp.ArrayError{Wanted: 2, Got: zb0001}
		return
	}
	err = z.SeqHashes.DecodeMsg(dc)
	if err != nil {
		err = msgp.WrapError(err, "SeqHashes")
		return
	}
	z.RequestId, err = dc.ReadUint32()
	if err != nil {
		err = msgp.WrapError(err, "RequestId")
		return
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *MessageBodiesRequest) EncodeMsg(en *msgp.Writer) (err error) {
	// array header, size 2
	err = en.Append(0x92)
	if err != nil {
		return
	}
	err = z.SeqHashes.EncodeMsg(en)
	if err != nil {
		err = msgp.WrapError(err, "SeqHashes")
		return
	}
	err = en.WriteUint32(z.RequestId)
	if err != nil {
		err = msgp.WrapError(err, "RequestId")
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *MessageBodiesRequest) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// array header, size 2
	o = append(o, 0x92)
	o, err = z.SeqHashes.MarshalMsg(o)
	if err != nil {
		err = msgp.WrapError(err, "SeqHashes")
		return
	}
	o = msgp.AppendUint32(o, z.RequestId)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *MessageBodiesRequest) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadArrayHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 2 {
		err = msgp.ArrayError{Wanted: 2, Got: zb0001}
		return
	}
	bts, err = z.SeqHashes.UnmarshalMsg(bts)
	if err != nil {
		err = msgp.WrapError(err, "SeqHashes")
		return
	}
	z.RequestId, bts, err = msgp.ReadUint32Bytes(bts)
	if err != nil {
		err = msgp.WrapError(err, "RequestId")
		return
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *MessageBodiesRequest) Msgsize() (s int) {
	s = 1 + z.SeqHashes.Msgsize() + msgp.Uint32Size
	return
}

// DecodeMsg implements msgp.Decodable
func (z *MessageBodiesResponse) DecodeMsg(dc *msgp.Reader) (err error) {
	var zb0001 uint32
	zb0001, err = dc.ReadArrayHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 2 {
		err = msgp.ArrayError{Wanted: 2, Got: zb0001}
		return
	}
	var zb0002 uint32
	zb0002, err = dc.ReadArrayHeader()
	if err != nil {
		err = msgp.WrapError(err, "Bodies")
		return
	}
	if cap(z.Bodies) >= int(zb0002) {
		z.Bodies = (z.Bodies)[:zb0002]
	} else {
		z.Bodies = make([]RawData, zb0002)
	}
	for za0001 := range z.Bodies {
		err = z.Bodies[za0001].DecodeMsg(dc)
		if err != nil {
			err = msgp.WrapError(err, "Bodies", za0001)
			return
		}
	}
	z.RequestedId, err = dc.ReadUint32()
	if err != nil {
		err = msgp.WrapError(err, "RequestId")
		return
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *MessageBodiesResponse) EncodeMsg(en *msgp.Writer) (err error) {
	// array header, size 2
	err = en.Append(0x92)
	if err != nil {
		return
	}
	err = en.WriteArrayHeader(uint32(len(z.Bodies)))
	if err != nil {
		err = msgp.WrapError(err, "Bodies")
		return
	}
	for za0001 := range z.Bodies {
		err = z.Bodies[za0001].EncodeMsg(en)
		if err != nil {
			err = msgp.WrapError(err, "Bodies", za0001)
			return
		}
	}
	err = en.WriteUint32(z.RequestedId)
	if err != nil {
		err = msgp.WrapError(err, "RequestId")
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *MessageBodiesResponse) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// array header, size 2
	o = append(o, 0x92)
	o = msgp.AppendArrayHeader(o, uint32(len(z.Bodies)))
	for za0001 := range z.Bodies {
		o, err = z.Bodies[za0001].MarshalMsg(o)
		if err != nil {
			err = msgp.WrapError(err, "Bodies", za0001)
			return
		}
	}
	o = msgp.AppendUint32(o, z.RequestedId)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *MessageBodiesResponse) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadArrayHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 2 {
		err = msgp.ArrayError{Wanted: 2, Got: zb0001}
		return
	}
	var zb0002 uint32
	zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err, "Bodies")
		return
	}
	if cap(z.Bodies) >= int(zb0002) {
		z.Bodies = (z.Bodies)[:zb0002]
	} else {
		z.Bodies = make([]RawData, zb0002)
	}
	for za0001 := range z.Bodies {
		bts, err = z.Bodies[za0001].UnmarshalMsg(bts)
		if err != nil {
			err = msgp.WrapError(err, "Bodies", za0001)
			return
		}
	}
	z.RequestedId, bts, err = msgp.ReadUint32Bytes(bts)
	if err != nil {
		err = msgp.WrapError(err, "RequestId")
		return
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *MessageBodiesResponse) Msgsize() (s int) {
	s = 1 + msgp.ArrayHeaderSize
	for za0001 := range z.Bodies {
		s += z.Bodies[za0001].Msgsize()
	}
	s += msgp.Uint32Size
	return
}

// DecodeMsg implements msgp.Decodable
func (z *MessageControl) DecodeMsg(dc *msgp.Reader) (err error) {
	var zb0001 uint32
	zb0001, err = dc.ReadArrayHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 1 {
		err = msgp.ArrayError{Wanted: 1, Got: zb0001}
		return
	}
	if dc.IsNil() {
		err = dc.ReadNil()
		if err != nil {
			err = msgp.WrapError(err, "Hash")
			return
		}
		z.Hash = nil
	} else {
		if z.Hash == nil {
			z.Hash = new(types.Hash)
		}
		err = z.Hash.DecodeMsg(dc)
		if err != nil {
			err = msgp.WrapError(err, "Hash")
			return
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *MessageControl) EncodeMsg(en *msgp.Writer) (err error) {
	// array header, size 1
	err = en.Append(0x91)
	if err != nil {
		return
	}
	if z.Hash == nil {
		err = en.WriteNil()
		if err != nil {
			return
		}
	} else {
		err = z.Hash.EncodeMsg(en)
		if err != nil {
			err = msgp.WrapError(err, "Hash")
			return
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *MessageControl) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// array header, size 1
	o = append(o, 0x91)
	if z.Hash == nil {
		o = msgp.AppendNil(o)
	} else {
		o, err = z.Hash.MarshalMsg(o)
		if err != nil {
			err = msgp.WrapError(err, "Hash")
			return
		}
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *MessageControl) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadArrayHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 1 {
		err = msgp.ArrayError{Wanted: 1, Got: zb0001}
		return
	}
	if msgp.IsNil(bts) {
		bts, err = msgp.ReadNilBytes(bts)
		if err != nil {
			return
		}
		z.Hash = nil
	} else {
		if z.Hash == nil {
			z.Hash = new(types.Hash)
		}
		bts, err = z.Hash.UnmarshalMsg(bts)
		if err != nil {
			err = msgp.WrapError(err, "Hash")
			return
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *MessageControl) Msgsize() (s int) {
	s = 1
	if z.Hash == nil {
		s += msgp.NilSize
	} else {
		s += z.Hash.Msgsize()
	}
	return
}

// DecodeMsg implements msgp.Decodable
func (z *MessageDuplicate) DecodeMsg(dc *msgp.Reader) (err error) {
	{
		var zb0001 bool
		zb0001, err = dc.ReadBool()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		(*z) = MessageDuplicate(zb0001)
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z MessageDuplicate) EncodeMsg(en *msgp.Writer) (err error) {
	err = en.WriteBool(bool(z))
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z MessageDuplicate) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	o = msgp.AppendBool(o, bool(z))
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *MessageDuplicate) UnmarshalMsg(bts []byte) (o []byte, err error) {
	{
		var zb0001 bool
		zb0001, bts, err = msgp.ReadBoolBytes(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		(*z) = MessageDuplicate(zb0001)
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z MessageDuplicate) Msgsize() (s int) {
	s = msgp.BoolSize
	return
}

// DecodeMsg implements msgp.Decodable
func (z *MessageGetMsg) DecodeMsg(dc *msgp.Reader) (err error) {
	var zb0001 uint32
	zb0001, err = dc.ReadArrayHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 1 {
		err = msgp.ArrayError{Wanted: 1, Got: zb0001}
		return
	}
	if dc.IsNil() {
		err = dc.ReadNil()
		if err != nil {
			err = msgp.WrapError(err, "Hash")
			return
		}
		z.Hash = nil
	} else {
		if z.Hash == nil {
			z.Hash = new(types.Hash)
		}
		err = z.Hash.DecodeMsg(dc)
		if err != nil {
			err = msgp.WrapError(err, "Hash")
			return
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *MessageGetMsg) EncodeMsg(en *msgp.Writer) (err error) {
	// array header, size 1
	err = en.Append(0x91)
	if err != nil {
		return
	}
	if z.Hash == nil {
		err = en.WriteNil()
		if err != nil {
			return
		}
	} else {
		err = z.Hash.EncodeMsg(en)
		if err != nil {
			err = msgp.WrapError(err, "Hash")
			return
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *MessageGetMsg) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// array header, size 1
	o = append(o, 0x91)
	if z.Hash == nil {
		o = msgp.AppendNil(o)
	} else {
		o, err = z.Hash.MarshalMsg(o)
		if err != nil {
			err = msgp.WrapError(err, "Hash")
			return
		}
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *MessageGetMsg) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadArrayHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 1 {
		err = msgp.ArrayError{Wanted: 1, Got: zb0001}
		return
	}
	if msgp.IsNil(bts) {
		bts, err = msgp.ReadNilBytes(bts)
		if err != nil {
			return
		}
		z.Hash = nil
	} else {
		if z.Hash == nil {
			z.Hash = new(types.Hash)
		}
		bts, err = z.Hash.UnmarshalMsg(bts)
		if err != nil {
			err = msgp.WrapError(err, "Hash")
			return
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *MessageGetMsg) Msgsize() (s int) {
	s = 1
	if z.Hash == nil {
		s += msgp.NilSize
	} else {
		s += z.Hash.Msgsize()
	}
	return
}

// DecodeMsg implements msgp.Decodable
func (z *MessageHeaderRequest) DecodeMsg(dc *msgp.Reader) (err error) {
	var zb0001 uint32
	zb0001, err = dc.ReadArrayHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 5 {
		err = msgp.ArrayError{Wanted: 5, Got: zb0001}
		return
	}
	err = z.Origin.DecodeMsg(dc)
	if err != nil {
		err = msgp.WrapError(err, "Origin")
		return
	}
	z.Amount, err = dc.ReadUint64()
	if err != nil {
		err = msgp.WrapError(err, "Amount")
		return
	}
	z.Skip, err = dc.ReadUint64()
	if err != nil {
		err = msgp.WrapError(err, "Skip")
		return
	}
	z.Reverse, err = dc.ReadBool()
	if err != nil {
		err = msgp.WrapError(err, "Reverse")
		return
	}
	z.RequestId, err = dc.ReadUint32()
	if err != nil {
		err = msgp.WrapError(err, "RequestId")
		return
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *MessageHeaderRequest) EncodeMsg(en *msgp.Writer) (err error) {
	// array header, size 5
	err = en.Append(0x95)
	if err != nil {
		return
	}
	err = z.Origin.EncodeMsg(en)
	if err != nil {
		err = msgp.WrapError(err, "Origin")
		return
	}
	err = en.WriteUint64(z.Amount)
	if err != nil {
		err = msgp.WrapError(err, "Amount")
		return
	}
	err = en.WriteUint64(z.Skip)
	if err != nil {
		err = msgp.WrapError(err, "Skip")
		return
	}
	err = en.WriteBool(z.Reverse)
	if err != nil {
		err = msgp.WrapError(err, "Reverse")
		return
	}
	err = en.WriteUint32(z.RequestId)
	if err != nil {
		err = msgp.WrapError(err, "RequestId")
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *MessageHeaderRequest) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// array header, size 5
	o = append(o, 0x95)
	o, err = z.Origin.MarshalMsg(o)
	if err != nil {
		err = msgp.WrapError(err, "Origin")
		return
	}
	o = msgp.AppendUint64(o, z.Amount)
	o = msgp.AppendUint64(o, z.Skip)
	o = msgp.AppendBool(o, z.Reverse)
	o = msgp.AppendUint32(o, z.RequestId)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *MessageHeaderRequest) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadArrayHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 5 {
		err = msgp.ArrayError{Wanted: 5, Got: zb0001}
		return
	}
	bts, err = z.Origin.UnmarshalMsg(bts)
	if err != nil {
		err = msgp.WrapError(err, "Origin")
		return
	}
	z.Amount, bts, err = msgp.ReadUint64Bytes(bts)
	if err != nil {
		err = msgp.WrapError(err, "Amount")
		return
	}
	z.Skip, bts, err = msgp.ReadUint64Bytes(bts)
	if err != nil {
		err = msgp.WrapError(err, "Skip")
		return
	}
	z.Reverse, bts, err = msgp.ReadBoolBytes(bts)
	if err != nil {
		err = msgp.WrapError(err, "Reverse")
		return
	}
	z.RequestId, bts, err = msgp.ReadUint32Bytes(bts)
	if err != nil {
		err = msgp.WrapError(err, "RequestId")
		return
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *MessageHeaderRequest) Msgsize() (s int) {
	s = 1 + z.Origin.Msgsize() + msgp.Uint64Size + msgp.Uint64Size + msgp.BoolSize + msgp.Uint32Size
	return
}

// DecodeMsg implements msgp.Decodable
func (z *MessageHeaderResponse) DecodeMsg(dc *msgp.Reader) (err error) {
	var zb0001 uint32
	zb0001, err = dc.ReadArrayHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 2 {
		err = msgp.ArrayError{Wanted: 2, Got: zb0001}
		return
	}
	if dc.IsNil() {
		err = dc.ReadNil()
		if err != nil {
			err = msgp.WrapError(err, "Headers")
			return
		}
		z.Headers = nil
	} else {
		if z.Headers == nil {
			z.Headers = new(dagmessage.SequencerHeaders)
		}
		err = z.Headers.DecodeMsg(dc)
		if err != nil {
			err = msgp.WrapError(err, "Headers")
			return
		}
	}
	z.RequestedId, err = dc.ReadUint32()
	if err != nil {
		err = msgp.WrapError(err, "RequestId")
		return
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *MessageHeaderResponse) EncodeMsg(en *msgp.Writer) (err error) {
	// array header, size 2
	err = en.Append(0x92)
	if err != nil {
		return
	}
	if z.Headers == nil {
		err = en.WriteNil()
		if err != nil {
			return
		}
	} else {
		err = z.Headers.EncodeMsg(en)
		if err != nil {
			err = msgp.WrapError(err, "Headers")
			return
		}
	}
	err = en.WriteUint32(z.RequestedId)
	if err != nil {
		err = msgp.WrapError(err, "RequestId")
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *MessageHeaderResponse) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// array header, size 2
	o = append(o, 0x92)
	if z.Headers == nil {
		o = msgp.AppendNil(o)
	} else {
		o, err = z.Headers.MarshalMsg(o)
		if err != nil {
			err = msgp.WrapError(err, "Headers")
			return
		}
	}
	o = msgp.AppendUint32(o, z.RequestedId)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *MessageHeaderResponse) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadArrayHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 2 {
		err = msgp.ArrayError{Wanted: 2, Got: zb0001}
		return
	}
	if msgp.IsNil(bts) {
		bts, err = msgp.ReadNilBytes(bts)
		if err != nil {
			return
		}
		z.Headers = nil
	} else {
		if z.Headers == nil {
			z.Headers = new(dagmessage.SequencerHeaders)
		}
		bts, err = z.Headers.UnmarshalMsg(bts)
		if err != nil {
			err = msgp.WrapError(err, "Headers")
			return
		}
	}
	z.RequestedId, bts, err = msgp.ReadUint32Bytes(bts)
	if err != nil {
		err = msgp.WrapError(err, "RequestId")
		return
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *MessageHeaderResponse) Msgsize() (s int) {
	s = 1
	if z.Headers == nil {
		s += msgp.NilSize
	} else {
		s += z.Headers.Msgsize()
	}
	s += msgp.Uint32Size
	return
}

// DecodeMsg implements msgp.Decodable
func (z *MessageNewActionTx) DecodeMsg(dc *msgp.Reader) (err error) {
	var zb0001 uint32
	zb0001, err = dc.ReadArrayHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 1 {
		err = msgp.ArrayError{Wanted: 1, Got: zb0001}
		return
	}
	if dc.IsNil() {
		err = dc.ReadNil()
		if err != nil {
			err = msgp.WrapError(err, "ActionTx")
			return
		}
		z.ActionTx = nil
	} else {
		if z.ActionTx == nil {
			z.ActionTx = new(ActionTx)
		}
		err = z.ActionTx.DecodeMsg(dc)
		if err != nil {
			err = msgp.WrapError(err, "ActionTx")
			return
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *MessageNewActionTx) EncodeMsg(en *msgp.Writer) (err error) {
	// array header, size 1
	err = en.Append(0x91)
	if err != nil {
		return
	}
	if z.ActionTx == nil {
		err = en.WriteNil()
		if err != nil {
			return
		}
	} else {
		err = z.ActionTx.EncodeMsg(en)
		if err != nil {
			err = msgp.WrapError(err, "ActionTx")
			return
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *MessageNewActionTx) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// array header, size 1
	o = append(o, 0x91)
	if z.ActionTx == nil {
		o = msgp.AppendNil(o)
	} else {
		o, err = z.ActionTx.MarshalMsg(o)
		if err != nil {
			err = msgp.WrapError(err, "ActionTx")
			return
		}
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *MessageNewActionTx) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadArrayHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 1 {
		err = msgp.ArrayError{Wanted: 1, Got: zb0001}
		return
	}
	if msgp.IsNil(bts) {
		bts, err = msgp.ReadNilBytes(bts)
		if err != nil {
			return
		}
		z.ActionTx = nil
	} else {
		if z.ActionTx == nil {
			z.ActionTx = new(ActionTx)
		}
		bts, err = z.ActionTx.UnmarshalMsg(bts)
		if err != nil {
			err = msgp.WrapError(err, "ActionTx")
			return
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *MessageNewActionTx) Msgsize() (s int) {
	s = 1
	if z.ActionTx == nil {
		s += msgp.NilSize
	} else {
		s += z.ActionTx.Msgsize()
	}
	return
}

// DecodeMsg implements msgp.Decodable
func (z *MessageNewSequencer) DecodeMsg(dc *msgp.Reader) (err error) {
	var zb0001 uint32
	zb0001, err = dc.ReadArrayHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 1 {
		err = msgp.ArrayError{Wanted: 1, Got: zb0001}
		return
	}
	if dc.IsNil() {
		err = dc.ReadNil()
		if err != nil {
			err = msgp.WrapError(err, "RawSequencer")
			return
		}
		z.RawSequencer = nil
	} else {
		if z.RawSequencer == nil {
			z.RawSequencer = new(RawSequencer)
		}
		err = z.RawSequencer.DecodeMsg(dc)
		if err != nil {
			err = msgp.WrapError(err, "RawSequencer")
			return
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *MessageNewSequencer) EncodeMsg(en *msgp.Writer) (err error) {
	// array header, size 1
	err = en.Append(0x91)
	if err != nil {
		return
	}
	if z.RawSequencer == nil {
		err = en.WriteNil()
		if err != nil {
			return
		}
	} else {
		err = z.RawSequencer.EncodeMsg(en)
		if err != nil {
			err = msgp.WrapError(err, "RawSequencer")
			return
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *MessageNewSequencer) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// array header, size 1
	o = append(o, 0x91)
	if z.RawSequencer == nil {
		o = msgp.AppendNil(o)
	} else {
		o, err = z.RawSequencer.MarshalMsg(o)
		if err != nil {
			err = msgp.WrapError(err, "RawSequencer")
			return
		}
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *MessageNewSequencer) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadArrayHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 1 {
		err = msgp.ArrayError{Wanted: 1, Got: zb0001}
		return
	}
	if msgp.IsNil(bts) {
		bts, err = msgp.ReadNilBytes(bts)
		if err != nil {
			return
		}
		z.RawSequencer = nil
	} else {
		if z.RawSequencer == nil {
			z.RawSequencer = new(RawSequencer)
		}
		bts, err = z.RawSequencer.UnmarshalMsg(bts)
		if err != nil {
			err = msgp.WrapError(err, "RawSequencer")
			return
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *MessageNewSequencer) Msgsize() (s int) {
	s = 1
	if z.RawSequencer == nil {
		s += msgp.NilSize
	} else {
		s += z.RawSequencer.Msgsize()
	}
	return
}

// DecodeMsg implements msgp.Decodable
func (z *MessageNewTx) DecodeMsg(dc *msgp.Reader) (err error) {
	var zb0001 uint32
	zb0001, err = dc.ReadArrayHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 1 {
		err = msgp.ArrayError{Wanted: 1, Got: zb0001}
		return
	}
	if dc.IsNil() {
		err = dc.ReadNil()
		if err != nil {
			err = msgp.WrapError(err, "RawTx")
			return
		}
		z.RawTx = nil
	} else {
		if z.RawTx == nil {
			z.RawTx = new(RawTx)
		}
		err = z.RawTx.DecodeMsg(dc)
		if err != nil {
			err = msgp.WrapError(err, "RawTx")
			return
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *MessageNewTx) EncodeMsg(en *msgp.Writer) (err error) {
	// array header, size 1
	err = en.Append(0x91)
	if err != nil {
		return
	}
	if z.RawTx == nil {
		err = en.WriteNil()
		if err != nil {
			return
		}
	} else {
		err = z.RawTx.EncodeMsg(en)
		if err != nil {
			err = msgp.WrapError(err, "RawTx")
			return
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *MessageNewTx) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// array header, size 1
	o = append(o, 0x91)
	if z.RawTx == nil {
		o = msgp.AppendNil(o)
	} else {
		o, err = z.RawTx.MarshalMsg(o)
		if err != nil {
			err = msgp.WrapError(err, "RawTx")
			return
		}
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *MessageNewTx) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadArrayHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 1 {
		err = msgp.ArrayError{Wanted: 1, Got: zb0001}
		return
	}
	if msgp.IsNil(bts) {
		bts, err = msgp.ReadNilBytes(bts)
		if err != nil {
			return
		}
		z.RawTx = nil
	} else {
		if z.RawTx == nil {
			z.RawTx = new(RawTx)
		}
		bts, err = z.RawTx.UnmarshalMsg(bts)
		if err != nil {
			err = msgp.WrapError(err, "RawTx")
			return
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *MessageNewTx) Msgsize() (s int) {
	s = 1
	if z.RawTx == nil {
		s += msgp.NilSize
	} else {
		s += z.RawTx.Msgsize()
	}
	return
}

// DecodeMsg implements msgp.Decodable
func (z *MessageNewTxs) DecodeMsg(dc *msgp.Reader) (err error) {
	var zb0001 uint32
	zb0001, err = dc.ReadArrayHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 1 {
		err = msgp.ArrayError{Wanted: 1, Got: zb0001}
		return
	}
	if dc.IsNil() {
		err = dc.ReadNil()
		if err != nil {
			err = msgp.WrapError(err, "RawTxs")
			return
		}
		z.RawTxs = nil
	} else {
		if z.RawTxs == nil {
			z.RawTxs = new(RawTxs)
		}
		err = z.RawTxs.DecodeMsg(dc)
		if err != nil {
			err = msgp.WrapError(err, "RawTxs")
			return
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *MessageNewTxs) EncodeMsg(en *msgp.Writer) (err error) {
	// array header, size 1
	err = en.Append(0x91)
	if err != nil {
		return
	}
	if z.RawTxs == nil {
		err = en.WriteNil()
		if err != nil {
			return
		}
	} else {
		err = z.RawTxs.EncodeMsg(en)
		if err != nil {
			err = msgp.WrapError(err, "RawTxs")
			return
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *MessageNewTxs) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// array header, size 1
	o = append(o, 0x91)
	if z.RawTxs == nil {
		o = msgp.AppendNil(o)
	} else {
		o, err = z.RawTxs.MarshalMsg(o)
		if err != nil {
			err = msgp.WrapError(err, "RawTxs")
			return
		}
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *MessageNewTxs) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadArrayHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 1 {
		err = msgp.ArrayError{Wanted: 1, Got: zb0001}
		return
	}
	if msgp.IsNil(bts) {
		bts, err = msgp.ReadNilBytes(bts)
		if err != nil {
			return
		}
		z.RawTxs = nil
	} else {
		if z.RawTxs == nil {
			z.RawTxs = new(RawTxs)
		}
		bts, err = z.RawTxs.UnmarshalMsg(bts)
		if err != nil {
			err = msgp.WrapError(err, "RawTxs")
			return
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *MessageNewTxs) Msgsize() (s int) {
	s = 1
	if z.RawTxs == nil {
		s += msgp.NilSize
	} else {
		s += z.RawTxs.Msgsize()
	}
	return
}

// DecodeMsg implements msgp.Decodable
func (z *MessagePing) DecodeMsg(dc *msgp.Reader) (err error) {
	var zb0001 uint32
	zb0001, err = dc.ReadArrayHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 0 {
		err = msgp.ArrayError{Wanted: 0, Got: zb0001}
		return
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z MessagePing) EncodeMsg(en *msgp.Writer) (err error) {
	// array header, size 0
	err = en.Append(0x90)
	if err != nil {
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z MessagePing) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// array header, size 0
	o = append(o, 0x90)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *MessagePing) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadArrayHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 0 {
		err = msgp.ArrayError{Wanted: 0, Got: zb0001}
		return
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z MessagePing) Msgsize() (s int) {
	s = 1
	return
}

// DecodeMsg implements msgp.Decodable
func (z *MessagePong) DecodeMsg(dc *msgp.Reader) (err error) {
	var zb0001 uint32
	zb0001, err = dc.ReadArrayHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 0 {
		err = msgp.ArrayError{Wanted: 0, Got: zb0001}
		return
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z MessagePong) EncodeMsg(en *msgp.Writer) (err error) {
	// array header, size 0
	err = en.Append(0x90)
	if err != nil {
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z MessagePong) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// array header, size 0
	o = append(o, 0x90)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *MessagePong) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadArrayHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 0 {
		err = msgp.ArrayError{Wanted: 0, Got: zb0001}
		return
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z MessagePong) Msgsize() (s int) {
	s = 1
	return
}

// DecodeMsg implements msgp.Decodable
func (z *MessageSequencerHeader) DecodeMsg(dc *msgp.Reader) (err error) {
	var zb0001 uint32
	zb0001, err = dc.ReadArrayHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 2 {
		err = msgp.ArrayError{Wanted: 2, Got: zb0001}
		return
	}
	if dc.IsNil() {
		err = dc.ReadNil()
		if err != nil {
			err = msgp.WrapError(err, "Hash")
			return
		}
		z.Hash = nil
	} else {
		if z.Hash == nil {
			z.Hash = new(types.Hash)
		}
		err = z.Hash.DecodeMsg(dc)
		if err != nil {
			err = msgp.WrapError(err, "Hash")
			return
		}
	}
	if dc.IsNil() {
		err = dc.ReadNil()
		if err != nil {
			err = msgp.WrapError(err, "Number")
			return
		}
		z.Number = nil
	} else {
		if z.Number == nil {
			z.Number = new(uint64)
		}
		*z.Number, err = dc.ReadUint64()
		if err != nil {
			err = msgp.WrapError(err, "Number")
			return
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *MessageSequencerHeader) EncodeMsg(en *msgp.Writer) (err error) {
	// array header, size 2
	err = en.Append(0x92)
	if err != nil {
		return
	}
	if z.Hash == nil {
		err = en.WriteNil()
		if err != nil {
			return
		}
	} else {
		err = z.Hash.EncodeMsg(en)
		if err != nil {
			err = msgp.WrapError(err, "Hash")
			return
		}
	}
	if z.Number == nil {
		err = en.WriteNil()
		if err != nil {
			return
		}
	} else {
		err = en.WriteUint64(*z.Number)
		if err != nil {
			err = msgp.WrapError(err, "Number")
			return
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *MessageSequencerHeader) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// array header, size 2
	o = append(o, 0x92)
	if z.Hash == nil {
		o = msgp.AppendNil(o)
	} else {
		o, err = z.Hash.MarshalMsg(o)
		if err != nil {
			err = msgp.WrapError(err, "Hash")
			return
		}
	}
	if z.Number == nil {
		o = msgp.AppendNil(o)
	} else {
		o = msgp.AppendUint64(o, *z.Number)
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *MessageSequencerHeader) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadArrayHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 2 {
		err = msgp.ArrayError{Wanted: 2, Got: zb0001}
		return
	}
	if msgp.IsNil(bts) {
		bts, err = msgp.ReadNilBytes(bts)
		if err != nil {
			return
		}
		z.Hash = nil
	} else {
		if z.Hash == nil {
			z.Hash = new(types.Hash)
		}
		bts, err = z.Hash.UnmarshalMsg(bts)
		if err != nil {
			err = msgp.WrapError(err, "Hash")
			return
		}
	}
	if msgp.IsNil(bts) {
		bts, err = msgp.ReadNilBytes(bts)
		if err != nil {
			return
		}
		z.Number = nil
	} else {
		if z.Number == nil {
			z.Number = new(uint64)
		}
		*z.Number, bts, err = msgp.ReadUint64Bytes(bts)
		if err != nil {
			err = msgp.WrapError(err, "Number")
			return
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *MessageSequencerHeader) Msgsize() (s int) {
	s = 1
	if z.Hash == nil {
		s += msgp.NilSize
	} else {
		s += z.Hash.Msgsize()
	}
	if z.Number == nil {
		s += msgp.NilSize
	} else {
		s += msgp.Uint64Size
	}
	return
}

// DecodeMsg implements msgp.Decodable
func (z *MessageSyncRequest) DecodeMsg(dc *msgp.Reader) (err error) {
	var zb0001 uint32
	zb0001, err = dc.ReadArrayHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 5 {
		err = msgp.ArrayError{Wanted: 5, Got: zb0001}
		return
	}
	if dc.IsNil() {
		err = dc.ReadNil()
		if err != nil {
			err = msgp.WrapError(err, "Hashes")
			return
		}
		z.Hashes = nil
	} else {
		if z.Hashes == nil {
			z.Hashes = new(types.Hashes)
		}
		err = z.Hashes.DecodeMsg(dc)
		if err != nil {
			err = msgp.WrapError(err, "Hashes")
			return
		}
	}
	if dc.IsNil() {
		err = dc.ReadNil()
		if err != nil {
			err = msgp.WrapError(err, "HashTerminats")
			return
		}
		z.HashTerminats = nil
	} else {
		if z.HashTerminats == nil {
			z.HashTerminats = new(HashTerminats)
		}
		err = z.HashTerminats.DecodeMsg(dc)
		if err != nil {
			err = msgp.WrapError(err, "HashTerminats")
			return
		}
	}
	if dc.IsNil() {
		err = dc.ReadNil()
		if err != nil {
			err = msgp.WrapError(err, "Filter")
			return
		}
		z.Filter = nil
	} else {
		if z.Filter == nil {
			z.Filter = new(BloomFilter)
		}
		err = z.Filter.DecodeMsg(dc)
		if err != nil {
			err = msgp.WrapError(err, "Filter")
			return
		}
	}
	if dc.IsNil() {
		err = dc.ReadNil()
		if err != nil {
			err = msgp.WrapError(err, "Height")
			return
		}
		z.Height = nil
	} else {
		if z.Height == nil {
			z.Height = new(uint64)
		}
		*z.Height, err = dc.ReadUint64()
		if err != nil {
			err = msgp.WrapError(err, "Height")
			return
		}
	}
	z.RequestId, err = dc.ReadUint32()
	if err != nil {
		err = msgp.WrapError(err, "RequestId")
		return
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *MessageSyncRequest) EncodeMsg(en *msgp.Writer) (err error) {
	// array header, size 5
	err = en.Append(0x95)
	if err != nil {
		return
	}
	if z.Hashes == nil {
		err = en.WriteNil()
		if err != nil {
			return
		}
	} else {
		err = z.Hashes.EncodeMsg(en)
		if err != nil {
			err = msgp.WrapError(err, "Hashes")
			return
		}
	}
	if z.HashTerminats == nil {
		err = en.WriteNil()
		if err != nil {
			return
		}
	} else {
		err = z.HashTerminats.EncodeMsg(en)
		if err != nil {
			err = msgp.WrapError(err, "HashTerminats")
			return
		}
	}
	if z.Filter == nil {
		err = en.WriteNil()
		if err != nil {
			return
		}
	} else {
		err = z.Filter.EncodeMsg(en)
		if err != nil {
			err = msgp.WrapError(err, "Filter")
			return
		}
	}
	if z.Height == nil {
		err = en.WriteNil()
		if err != nil {
			return
		}
	} else {
		err = en.WriteUint64(*z.Height)
		if err != nil {
			err = msgp.WrapError(err, "Height")
			return
		}
	}
	err = en.WriteUint32(z.RequestId)
	if err != nil {
		err = msgp.WrapError(err, "RequestId")
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *MessageSyncRequest) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// array header, size 5
	o = append(o, 0x95)
	if z.Hashes == nil {
		o = msgp.AppendNil(o)
	} else {
		o, err = z.Hashes.MarshalMsg(o)
		if err != nil {
			err = msgp.WrapError(err, "Hashes")
			return
		}
	}
	if z.HashTerminats == nil {
		o = msgp.AppendNil(o)
	} else {
		o, err = z.HashTerminats.MarshalMsg(o)
		if err != nil {
			err = msgp.WrapError(err, "HashTerminats")
			return
		}
	}
	if z.Filter == nil {
		o = msgp.AppendNil(o)
	} else {
		o, err = z.Filter.MarshalMsg(o)
		if err != nil {
			err = msgp.WrapError(err, "Filter")
			return
		}
	}
	if z.Height == nil {
		o = msgp.AppendNil(o)
	} else {
		o = msgp.AppendUint64(o, *z.Height)
	}
	o = msgp.AppendUint32(o, z.RequestId)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *MessageSyncRequest) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadArrayHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 5 {
		err = msgp.ArrayError{Wanted: 5, Got: zb0001}
		return
	}
	if msgp.IsNil(bts) {
		bts, err = msgp.ReadNilBytes(bts)
		if err != nil {
			return
		}
		z.Hashes = nil
	} else {
		if z.Hashes == nil {
			z.Hashes = new(types.Hashes)
		}
		bts, err = z.Hashes.UnmarshalMsg(bts)
		if err != nil {
			err = msgp.WrapError(err, "Hashes")
			return
		}
	}
	if msgp.IsNil(bts) {
		bts, err = msgp.ReadNilBytes(bts)
		if err != nil {
			return
		}
		z.HashTerminats = nil
	} else {
		if z.HashTerminats == nil {
			z.HashTerminats = new(HashTerminats)
		}
		bts, err = z.HashTerminats.UnmarshalMsg(bts)
		if err != nil {
			err = msgp.WrapError(err, "HashTerminats")
			return
		}
	}
	if msgp.IsNil(bts) {
		bts, err = msgp.ReadNilBytes(bts)
		if err != nil {
			return
		}
		z.Filter = nil
	} else {
		if z.Filter == nil {
			z.Filter = new(BloomFilter)
		}
		bts, err = z.Filter.UnmarshalMsg(bts)
		if err != nil {
			err = msgp.WrapError(err, "Filter")
			return
		}
	}
	if msgp.IsNil(bts) {
		bts, err = msgp.ReadNilBytes(bts)
		if err != nil {
			return
		}
		z.Height = nil
	} else {
		if z.Height == nil {
			z.Height = new(uint64)
		}
		*z.Height, bts, err = msgp.ReadUint64Bytes(bts)
		if err != nil {
			err = msgp.WrapError(err, "Height")
			return
		}
	}
	z.RequestId, bts, err = msgp.ReadUint32Bytes(bts)
	if err != nil {
		err = msgp.WrapError(err, "RequestId")
		return
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *MessageSyncRequest) Msgsize() (s int) {
	s = 1
	if z.Hashes == nil {
		s += msgp.NilSize
	} else {
		s += z.Hashes.Msgsize()
	}
	if z.HashTerminats == nil {
		s += msgp.NilSize
	} else {
		s += z.HashTerminats.Msgsize()
	}
	if z.Filter == nil {
		s += msgp.NilSize
	} else {
		s += z.Filter.Msgsize()
	}
	if z.Height == nil {
		s += msgp.NilSize
	} else {
		s += msgp.Uint64Size
	}
	s += msgp.Uint32Size
	return
}

// DecodeMsg implements msgp.Decodable
func (z *MessageSyncResponse) DecodeMsg(dc *msgp.Reader) (err error) {
	var zb0001 uint32
	zb0001, err = dc.ReadArrayHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 2 {
		err = msgp.ArrayError{Wanted: 2, Got: zb0001}
		return
	}
	if dc.IsNil() {
		err = dc.ReadNil()
		if err != nil {
			err = msgp.WrapError(err, "RawTxs")
			return
		}
		z.RawTxs = nil
	} else {
		if z.RawTxs == nil {
			z.RawTxs = new(TxisMarshaler)
		}
		err = z.RawTxs.DecodeMsg(dc)
		if err != nil {
			err = msgp.WrapError(err, "RawTxs")
			return
		}
	}
	z.RequestedId, err = dc.ReadUint32()
	if err != nil {
		err = msgp.WrapError(err, "RequestId")
		return
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *MessageSyncResponse) EncodeMsg(en *msgp.Writer) (err error) {
	// array header, size 2
	err = en.Append(0x92)
	if err != nil {
		return
	}
	if z.RawTxs == nil {
		err = en.WriteNil()
		if err != nil {
			return
		}
	} else {
		err = z.RawTxs.EncodeMsg(en)
		if err != nil {
			err = msgp.WrapError(err, "RawTxs")
			return
		}
	}
	err = en.WriteUint32(z.RequestedId)
	if err != nil {
		err = msgp.WrapError(err, "RequestId")
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *MessageSyncResponse) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// array header, size 2
	o = append(o, 0x92)
	if z.RawTxs == nil {
		o = msgp.AppendNil(o)
	} else {
		o, err = z.RawTxs.MarshalMsg(o)
		if err != nil {
			err = msgp.WrapError(err, "RawTxs")
			return
		}
	}
	o = msgp.AppendUint32(o, z.RequestedId)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *MessageSyncResponse) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadArrayHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 2 {
		err = msgp.ArrayError{Wanted: 2, Got: zb0001}
		return
	}
	if msgp.IsNil(bts) {
		bts, err = msgp.ReadNilBytes(bts)
		if err != nil {
			return
		}
		z.RawTxs = nil
	} else {
		if z.RawTxs == nil {
			z.RawTxs = new(TxisMarshaler)
		}
		bts, err = z.RawTxs.UnmarshalMsg(bts)
		if err != nil {
			err = msgp.WrapError(err, "RawTxs")
			return
		}
	}
	z.RequestedId, bts, err = msgp.ReadUint32Bytes(bts)
	if err != nil {
		err = msgp.WrapError(err, "RequestId")
		return
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *MessageSyncResponse) Msgsize() (s int) {
	s = 1
	if z.RawTxs == nil {
		s += msgp.NilSize
	} else {
		s += z.RawTxs.Msgsize()
	}
	s += msgp.Uint32Size
	return
}

// DecodeMsg implements msgp.Decodable
func (z *MessageTxsRequest) DecodeMsg(dc *msgp.Reader) (err error) {
	var zb0001 uint32
	zb0001, err = dc.ReadArrayHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 4 {
		err = msgp.ArrayError{Wanted: 4, Got: zb0001}
		return
	}
	if dc.IsNil() {
		err = dc.ReadNil()
		if err != nil {
			err = msgp.WrapError(err, "Hashes")
			return
		}
		z.Hashes = nil
	} else {
		if z.Hashes == nil {
			z.Hashes = new(types.Hashes)
		}
		err = z.Hashes.DecodeMsg(dc)
		if err != nil {
			err = msgp.WrapError(err, "Hashes")
			return
		}
	}
	if dc.IsNil() {
		err = dc.ReadNil()
		if err != nil {
			err = msgp.WrapError(err, "SeqHash")
			return
		}
		z.SeqHash = nil
	} else {
		if z.SeqHash == nil {
			z.SeqHash = new(types.Hash)
		}
		err = z.SeqHash.DecodeMsg(dc)
		if err != nil {
			err = msgp.WrapError(err, "SeqHash")
			return
		}
	}
	if dc.IsNil() {
		err = dc.ReadNil()
		if err != nil {
			err = msgp.WrapError(err, "Id")
			return
		}
		z.Id = nil
	} else {
		if z.Id == nil {
			z.Id = new(uint64)
		}
		*z.Id, err = dc.ReadUint64()
		if err != nil {
			err = msgp.WrapError(err, "Id")
			return
		}
	}
	z.RequestId, err = dc.ReadUint32()
	if err != nil {
		err = msgp.WrapError(err, "RequestId")
		return
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *MessageTxsRequest) EncodeMsg(en *msgp.Writer) (err error) {
	// array header, size 4
	err = en.Append(0x94)
	if err != nil {
		return
	}
	if z.Hashes == nil {
		err = en.WriteNil()
		if err != nil {
			return
		}
	} else {
		err = z.Hashes.EncodeMsg(en)
		if err != nil {
			err = msgp.WrapError(err, "Hashes")
			return
		}
	}
	if z.SeqHash == nil {
		err = en.WriteNil()
		if err != nil {
			return
		}
	} else {
		err = z.SeqHash.EncodeMsg(en)
		if err != nil {
			err = msgp.WrapError(err, "SeqHash")
			return
		}
	}
	if z.Id == nil {
		err = en.WriteNil()
		if err != nil {
			return
		}
	} else {
		err = en.WriteUint64(*z.Id)
		if err != nil {
			err = msgp.WrapError(err, "Id")
			return
		}
	}
	err = en.WriteUint32(z.RequestId)
	if err != nil {
		err = msgp.WrapError(err, "RequestId")
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *MessageTxsRequest) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// array header, size 4
	o = append(o, 0x94)
	if z.Hashes == nil {
		o = msgp.AppendNil(o)
	} else {
		o, err = z.Hashes.MarshalMsg(o)
		if err != nil {
			err = msgp.WrapError(err, "Hashes")
			return
		}
	}
	if z.SeqHash == nil {
		o = msgp.AppendNil(o)
	} else {
		o, err = z.SeqHash.MarshalMsg(o)
		if err != nil {
			err = msgp.WrapError(err, "SeqHash")
			return
		}
	}
	if z.Id == nil {
		o = msgp.AppendNil(o)
	} else {
		o = msgp.AppendUint64(o, *z.Id)
	}
	o = msgp.AppendUint32(o, z.RequestId)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *MessageTxsRequest) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadArrayHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 4 {
		err = msgp.ArrayError{Wanted: 4, Got: zb0001}
		return
	}
	if msgp.IsNil(bts) {
		bts, err = msgp.ReadNilBytes(bts)
		if err != nil {
			return
		}
		z.Hashes = nil
	} else {
		if z.Hashes == nil {
			z.Hashes = new(types.Hashes)
		}
		bts, err = z.Hashes.UnmarshalMsg(bts)
		if err != nil {
			err = msgp.WrapError(err, "Hashes")
			return
		}
	}
	if msgp.IsNil(bts) {
		bts, err = msgp.ReadNilBytes(bts)
		if err != nil {
			return
		}
		z.SeqHash = nil
	} else {
		if z.SeqHash == nil {
			z.SeqHash = new(types.Hash)
		}
		bts, err = z.SeqHash.UnmarshalMsg(bts)
		if err != nil {
			err = msgp.WrapError(err, "SeqHash")
			return
		}
	}
	if msgp.IsNil(bts) {
		bts, err = msgp.ReadNilBytes(bts)
		if err != nil {
			return
		}
		z.Id = nil
	} else {
		if z.Id == nil {
			z.Id = new(uint64)
		}
		*z.Id, bts, err = msgp.ReadUint64Bytes(bts)
		if err != nil {
			err = msgp.WrapError(err, "Id")
			return
		}
	}
	z.RequestId, bts, err = msgp.ReadUint32Bytes(bts)
	if err != nil {
		err = msgp.WrapError(err, "RequestId")
		return
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *MessageTxsRequest) Msgsize() (s int) {
	s = 1
	if z.Hashes == nil {
		s += msgp.NilSize
	} else {
		s += z.Hashes.Msgsize()
	}
	if z.SeqHash == nil {
		s += msgp.NilSize
	} else {
		s += z.SeqHash.Msgsize()
	}
	if z.Id == nil {
		s += msgp.NilSize
	} else {
		s += msgp.Uint64Size
	}
	s += msgp.Uint32Size
	return
}

// DecodeMsg implements msgp.Decodable
func (z *MessageTxsResponse) DecodeMsg(dc *msgp.Reader) (err error) {
	var zb0001 uint32
	zb0001, err = dc.ReadArrayHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 3 {
		err = msgp.ArrayError{Wanted: 3, Got: zb0001}
		return
	}
	if dc.IsNil() {
		err = dc.ReadNil()
		if err != nil {
			err = msgp.WrapError(err, "RawSequencer")
			return
		}
		z.RawSequencer = nil
	} else {
		if z.RawSequencer == nil {
			z.RawSequencer = new(RawSequencer)
		}
		err = z.RawSequencer.DecodeMsg(dc)
		if err != nil {
			err = msgp.WrapError(err, "RawSequencer")
			return
		}
	}
	if dc.IsNil() {
		err = dc.ReadNil()
		if err != nil {
			err = msgp.WrapError(err, "RawTxs")
			return
		}
		z.RawTxs = nil
	} else {
		if z.RawTxs == nil {
			z.RawTxs = new(TxisMarshaler)
		}
		err = z.RawTxs.DecodeMsg(dc)
		if err != nil {
			err = msgp.WrapError(err, "RawTxs")
			return
		}
	}
	z.RequestedId, err = dc.ReadUint32()
	if err != nil {
		err = msgp.WrapError(err, "RequestId")
		return
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *MessageTxsResponse) EncodeMsg(en *msgp.Writer) (err error) {
	// array header, size 3
	err = en.Append(0x93)
	if err != nil {
		return
	}
	if z.RawSequencer == nil {
		err = en.WriteNil()
		if err != nil {
			return
		}
	} else {
		err = z.RawSequencer.EncodeMsg(en)
		if err != nil {
			err = msgp.WrapError(err, "RawSequencer")
			return
		}
	}
	if z.RawTxs == nil {
		err = en.WriteNil()
		if err != nil {
			return
		}
	} else {
		err = z.RawTxs.EncodeMsg(en)
		if err != nil {
			err = msgp.WrapError(err, "RawTxs")
			return
		}
	}
	err = en.WriteUint32(z.RequestedId)
	if err != nil {
		err = msgp.WrapError(err, "RequestId")
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *MessageTxsResponse) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// array header, size 3
	o = append(o, 0x93)
	if z.RawSequencer == nil {
		o = msgp.AppendNil(o)
	} else {
		o, err = z.RawSequencer.MarshalMsg(o)
		if err != nil {
			err = msgp.WrapError(err, "RawSequencer")
			return
		}
	}
	if z.RawTxs == nil {
		o = msgp.AppendNil(o)
	} else {
		o, err = z.RawTxs.MarshalMsg(o)
		if err != nil {
			err = msgp.WrapError(err, "RawTxs")
			return
		}
	}
	o = msgp.AppendUint32(o, z.RequestedId)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *MessageTxsResponse) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadArrayHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 3 {
		err = msgp.ArrayError{Wanted: 3, Got: zb0001}
		return
	}
	if msgp.IsNil(bts) {
		bts, err = msgp.ReadNilBytes(bts)
		if err != nil {
			return
		}
		z.RawSequencer = nil
	} else {
		if z.RawSequencer == nil {
			z.RawSequencer = new(RawSequencer)
		}
		bts, err = z.RawSequencer.UnmarshalMsg(bts)
		if err != nil {
			err = msgp.WrapError(err, "RawSequencer")
			return
		}
	}
	if msgp.IsNil(bts) {
		bts, err = msgp.ReadNilBytes(bts)
		if err != nil {
			return
		}
		z.RawTxs = nil
	} else {
		if z.RawTxs == nil {
			z.RawTxs = new(TxisMarshaler)
		}
		bts, err = z.RawTxs.UnmarshalMsg(bts)
		if err != nil {
			err = msgp.WrapError(err, "RawTxs")
			return
		}
	}
	z.RequestedId, bts, err = msgp.ReadUint32Bytes(bts)
	if err != nil {
		err = msgp.WrapError(err, "RequestId")
		return
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *MessageTxsResponse) Msgsize() (s int) {
	s = 1
	if z.RawSequencer == nil {
		s += msgp.NilSize
	} else {
		s += z.RawSequencer.Msgsize()
	}
	if z.RawTxs == nil {
		s += msgp.NilSize
	} else {
		s += z.RawTxs.Msgsize()
	}
	s += msgp.Uint32Size
	return
}