package storagesc

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

import (
	"github.com/tinylib/msgp/msgp"
)

// MarshalMsg implements msgp.Marshaler
func (z *AllocOpenChallenge) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 4
	// string "ID"
	o = append(o, 0x84, 0xa2, 0x49, 0x44)
	o = msgp.AppendString(o, z.ID)
	// string "CreatedAt"
	o = append(o, 0xa9, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74)
	o, err = z.CreatedAt.MarshalMsg(o)
	if err != nil {
		err = msgp.WrapError(err, "CreatedAt")
		return
	}
	// string "RoundCreatedAt"
	o = append(o, 0xae, 0x52, 0x6f, 0x75, 0x6e, 0x64, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74)
	o = msgp.AppendInt64(o, z.RoundCreatedAt)
	// string "BlobberID"
	o = append(o, 0xa9, 0x42, 0x6c, 0x6f, 0x62, 0x62, 0x65, 0x72, 0x49, 0x44)
	o = msgp.AppendString(o, z.BlobberID)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *AllocOpenChallenge) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "ID":
			z.ID, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ID")
				return
			}
		case "CreatedAt":
			bts, err = z.CreatedAt.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "CreatedAt")
				return
			}
		case "RoundCreatedAt":
			z.RoundCreatedAt, bts, err = msgp.ReadInt64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "RoundCreatedAt")
				return
			}
		case "BlobberID":
			z.BlobberID, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "BlobberID")
				return
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *AllocOpenChallenge) Msgsize() (s int) {
	s = 1 + 3 + msgp.StringPrefixSize + len(z.ID) + 10 + z.CreatedAt.Msgsize() + 15 + msgp.Int64Size + 10 + msgp.StringPrefixSize + len(z.BlobberID)
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *Allocations) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 1
	// string "List"
	o = append(o, 0x81, 0xa4, 0x4c, 0x69, 0x73, 0x74)
	o, err = z.List.MarshalMsg(o)
	if err != nil {
		err = msgp.WrapError(err, "List")
		return
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *Allocations) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "List":
			bts, err = z.List.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "List")
				return
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

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

// MarshalMsg implements msgp.Marshaler
func (z *BlobberAllocation) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 14
	// string "BlobberID"
	o = append(o, 0x8e, 0xa9, 0x42, 0x6c, 0x6f, 0x62, 0x62, 0x65, 0x72, 0x49, 0x44)
	o = msgp.AppendString(o, z.BlobberID)
	// string "AllocationID"
	o = append(o, 0xac, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44)
	o = msgp.AppendString(o, z.AllocationID)
	// string "Size"
	o = append(o, 0xa4, 0x53, 0x69, 0x7a, 0x65)
	o = msgp.AppendInt64(o, z.Size)
	// string "AllocationRoot"
	o = append(o, 0xae, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x6f, 0x6f, 0x74)
	o = msgp.AppendString(o, z.AllocationRoot)
	// string "LastWriteMarker"
	o = append(o, 0xaf, 0x4c, 0x61, 0x73, 0x74, 0x57, 0x72, 0x69, 0x74, 0x65, 0x4d, 0x61, 0x72, 0x6b, 0x65, 0x72)
	if z.LastWriteMarker == nil {
		o = msgp.AppendNil(o)
	} else {
		o, err = z.LastWriteMarker.MarshalMsg(o)
		if err != nil {
			err = msgp.WrapError(err, "LastWriteMarker")
			return
		}
	}
	// string "Stats"
	o = append(o, 0xa5, 0x53, 0x74, 0x61, 0x74, 0x73)
	if z.Stats == nil {
		o = msgp.AppendNil(o)
	} else {
		o, err = z.Stats.MarshalMsg(o)
		if err != nil {
			err = msgp.WrapError(err, "Stats")
			return
		}
	}
	// string "Terms"
	o = append(o, 0xa5, 0x54, 0x65, 0x72, 0x6d, 0x73)
	// map header, size 2
	// string "ReadPrice"
	o = append(o, 0x82, 0xa9, 0x52, 0x65, 0x61, 0x64, 0x50, 0x72, 0x69, 0x63, 0x65)
	o, err = z.Terms.ReadPrice.MarshalMsg(o)
	if err != nil {
		err = msgp.WrapError(err, "Terms", "ReadPrice")
		return
	}
	// string "WritePrice"
	o = append(o, 0xaa, 0x57, 0x72, 0x69, 0x74, 0x65, 0x50, 0x72, 0x69, 0x63, 0x65)
	o, err = z.Terms.WritePrice.MarshalMsg(o)
	if err != nil {
		err = msgp.WrapError(err, "Terms", "WritePrice")
		return
	}
	// string "Penalty"
	o = append(o, 0xa7, 0x50, 0x65, 0x6e, 0x61, 0x6c, 0x74, 0x79)
	o, err = z.Penalty.MarshalMsg(o)
	if err != nil {
		err = msgp.WrapError(err, "Penalty")
		return
	}
	// string "ReadReward"
	o = append(o, 0xaa, 0x52, 0x65, 0x61, 0x64, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64)
	o, err = z.ReadReward.MarshalMsg(o)
	if err != nil {
		err = msgp.WrapError(err, "ReadReward")
		return
	}
	// string "Returned"
	o = append(o, 0xa8, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x65, 0x64)
	o, err = z.Returned.MarshalMsg(o)
	if err != nil {
		err = msgp.WrapError(err, "Returned")
		return
	}
	// string "ChallengeReward"
	o = append(o, 0xaf, 0x43, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64)
	o, err = z.ChallengeReward.MarshalMsg(o)
	if err != nil {
		err = msgp.WrapError(err, "ChallengeReward")
		return
	}
	// string "ChallengePoolIntegralValue"
	o = append(o, 0xba, 0x43, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x50, 0x6f, 0x6f, 0x6c, 0x49, 0x6e, 0x74, 0x65, 0x67, 0x72, 0x61, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65)
	o, err = z.ChallengePoolIntegralValue.MarshalMsg(o)
	if err != nil {
		err = msgp.WrapError(err, "ChallengePoolIntegralValue")
		return
	}
	// string "LatestSuccessfulChallCreatedAt"
	o = append(o, 0xbe, 0x4c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x53, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x66, 0x75, 0x6c, 0x43, 0x68, 0x61, 0x6c, 0x6c, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74)
	o, err = z.LatestSuccessfulChallCreatedAt.MarshalMsg(o)
	if err != nil {
		err = msgp.WrapError(err, "LatestSuccessfulChallCreatedAt")
		return
	}
	// string "LatestFinalizedChallCreatedAt"
	o = append(o, 0xbd, 0x4c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x43, 0x68, 0x61, 0x6c, 0x6c, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74)
	o, err = z.LatestFinalizedChallCreatedAt.MarshalMsg(o)
	if err != nil {
		err = msgp.WrapError(err, "LatestFinalizedChallCreatedAt")
		return
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *BlobberAllocation) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "BlobberID":
			z.BlobberID, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "BlobberID")
				return
			}
		case "AllocationID":
			z.AllocationID, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "AllocationID")
				return
			}
		case "Size":
			z.Size, bts, err = msgp.ReadInt64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Size")
				return
			}
		case "AllocationRoot":
			z.AllocationRoot, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "AllocationRoot")
				return
			}
		case "LastWriteMarker":
			if msgp.IsNil(bts) {
				bts, err = msgp.ReadNilBytes(bts)
				if err != nil {
					return
				}
				z.LastWriteMarker = nil
			} else {
				if z.LastWriteMarker == nil {
					z.LastWriteMarker = new(WriteMarker)
				}
				bts, err = z.LastWriteMarker.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "LastWriteMarker")
					return
				}
			}
		case "Stats":
			if msgp.IsNil(bts) {
				bts, err = msgp.ReadNilBytes(bts)
				if err != nil {
					return
				}
				z.Stats = nil
			} else {
				if z.Stats == nil {
					z.Stats = new(StorageAllocationStats)
				}
				bts, err = z.Stats.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "Stats")
					return
				}
			}
		case "Terms":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadMapHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Terms")
				return
			}
			for zb0002 > 0 {
				zb0002--
				field, bts, err = msgp.ReadMapKeyZC(bts)
				if err != nil {
					err = msgp.WrapError(err, "Terms")
					return
				}
				switch msgp.UnsafeString(field) {
				case "ReadPrice":
					bts, err = z.Terms.ReadPrice.UnmarshalMsg(bts)
					if err != nil {
						err = msgp.WrapError(err, "Terms", "ReadPrice")
						return
					}
				case "WritePrice":
					bts, err = z.Terms.WritePrice.UnmarshalMsg(bts)
					if err != nil {
						err = msgp.WrapError(err, "Terms", "WritePrice")
						return
					}
				default:
					bts, err = msgp.Skip(bts)
					if err != nil {
						err = msgp.WrapError(err, "Terms")
						return
					}
				}
			}
		case "Penalty":
			bts, err = z.Penalty.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "Penalty")
				return
			}
		case "ReadReward":
			bts, err = z.ReadReward.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "ReadReward")
				return
			}
		case "Returned":
			bts, err = z.Returned.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "Returned")
				return
			}
		case "ChallengeReward":
			bts, err = z.ChallengeReward.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "ChallengeReward")
				return
			}
		case "ChallengePoolIntegralValue":
			bts, err = z.ChallengePoolIntegralValue.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "ChallengePoolIntegralValue")
				return
			}
		case "LatestSuccessfulChallCreatedAt":
			bts, err = z.LatestSuccessfulChallCreatedAt.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "LatestSuccessfulChallCreatedAt")
				return
			}
		case "LatestFinalizedChallCreatedAt":
			bts, err = z.LatestFinalizedChallCreatedAt.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "LatestFinalizedChallCreatedAt")
				return
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *BlobberAllocation) Msgsize() (s int) {
	s = 1 + 10 + msgp.StringPrefixSize + len(z.BlobberID) + 13 + msgp.StringPrefixSize + len(z.AllocationID) + 5 + msgp.Int64Size + 15 + msgp.StringPrefixSize + len(z.AllocationRoot) + 16
	if z.LastWriteMarker == nil {
		s += msgp.NilSize
	} else {
		s += z.LastWriteMarker.Msgsize()
	}
	s += 6
	if z.Stats == nil {
		s += msgp.NilSize
	} else {
		s += z.Stats.Msgsize()
	}
	s += 6 + 1 + 10 + z.Terms.ReadPrice.Msgsize() + 11 + z.Terms.WritePrice.Msgsize() + 8 + z.Penalty.Msgsize() + 11 + z.ReadReward.Msgsize() + 9 + z.Returned.Msgsize() + 16 + z.ChallengeReward.Msgsize() + 27 + z.ChallengePoolIntegralValue.Msgsize() + 31 + z.LatestSuccessfulChallCreatedAt.Msgsize() + 30 + z.LatestFinalizedChallCreatedAt.Msgsize()
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *BlobberCloseConnection) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 4
	// string "AllocationRoot"
	o = append(o, 0x84, 0xae, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x6f, 0x6f, 0x74)
	o = msgp.AppendString(o, z.AllocationRoot)
	// string "PrevAllocationRoot"
	o = append(o, 0xb2, 0x50, 0x72, 0x65, 0x76, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x6f, 0x6f, 0x74)
	o = msgp.AppendString(o, z.PrevAllocationRoot)
	// string "WriteMarker"
	o = append(o, 0xab, 0x57, 0x72, 0x69, 0x74, 0x65, 0x4d, 0x61, 0x72, 0x6b, 0x65, 0x72)
	if z.WriteMarker == nil {
		o = msgp.AppendNil(o)
	} else {
		o, err = z.WriteMarker.MarshalMsg(o)
		if err != nil {
			err = msgp.WrapError(err, "WriteMarker")
			return
		}
	}
	// string "ChainData"
	o = append(o, 0xa9, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x44, 0x61, 0x74, 0x61)
	o = msgp.AppendBytes(o, z.ChainData)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *BlobberCloseConnection) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "AllocationRoot":
			z.AllocationRoot, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "AllocationRoot")
				return
			}
		case "PrevAllocationRoot":
			z.PrevAllocationRoot, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "PrevAllocationRoot")
				return
			}
		case "WriteMarker":
			if msgp.IsNil(bts) {
				bts, err = msgp.ReadNilBytes(bts)
				if err != nil {
					return
				}
				z.WriteMarker = nil
			} else {
				if z.WriteMarker == nil {
					z.WriteMarker = new(WriteMarker)
				}
				bts, err = z.WriteMarker.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "WriteMarker")
					return
				}
			}
		case "ChainData":
			z.ChainData, bts, err = msgp.ReadBytesBytes(bts, z.ChainData)
			if err != nil {
				err = msgp.WrapError(err, "ChainData")
				return
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *BlobberCloseConnection) Msgsize() (s int) {
	s = 1 + 15 + msgp.StringPrefixSize + len(z.AllocationRoot) + 19 + msgp.StringPrefixSize + len(z.PrevAllocationRoot) + 12
	if z.WriteMarker == nil {
		s += msgp.NilSize
	} else {
		s += z.WriteMarker.Msgsize()
	}
	s += 10 + msgp.BytesPrefixSize + len(z.ChainData)
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *ChallengePoolChanges) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 2
	// string "Value"
	o = append(o, 0x82, 0xa5, 0x56, 0x61, 0x6c, 0x75, 0x65)
	o, err = z.Value.MarshalMsg(o)
	if err != nil {
		err = msgp.WrapError(err, "Value")
		return
	}
	// string "isNegative"
	o = append(o, 0xaa, 0x69, 0x73, 0x4e, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65)
	o = msgp.AppendBool(o, z.isNegative)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *ChallengePoolChanges) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "Value":
			bts, err = z.Value.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "Value")
				return
			}
		case "isNegative":
			z.isNegative, bts, err = msgp.ReadBoolBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "isNegative")
				return
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *ChallengePoolChanges) Msgsize() (s int) {
	s = 1 + 6 + z.Value.Msgsize() + 11 + msgp.BoolSize
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *ChallengeResponse) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 2
	// string "ID"
	o = append(o, 0x82, 0xa2, 0x49, 0x44)
	o = msgp.AppendString(o, z.ID)
	// string "ValidationTickets"
	o = append(o, 0xb1, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x73)
	o = msgp.AppendArrayHeader(o, uint32(len(z.ValidationTickets)))
	for za0001 := range z.ValidationTickets {
		if z.ValidationTickets[za0001] == nil {
			o = msgp.AppendNil(o)
		} else {
			o, err = z.ValidationTickets[za0001].MarshalMsg(o)
			if err != nil {
				err = msgp.WrapError(err, "ValidationTickets", za0001)
				return
			}
		}
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *ChallengeResponse) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "ID":
			z.ID, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ID")
				return
			}
		case "ValidationTickets":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ValidationTickets")
				return
			}
			if cap(z.ValidationTickets) >= int(zb0002) {
				z.ValidationTickets = (z.ValidationTickets)[:zb0002]
			} else {
				z.ValidationTickets = make([]*ValidationTicket, zb0002)
			}
			for za0001 := range z.ValidationTickets {
				if msgp.IsNil(bts) {
					bts, err = msgp.ReadNilBytes(bts)
					if err != nil {
						return
					}
					z.ValidationTickets[za0001] = nil
				} else {
					if z.ValidationTickets[za0001] == nil {
						z.ValidationTickets[za0001] = new(ValidationTicket)
					}
					bts, err = z.ValidationTickets[za0001].UnmarshalMsg(bts)
					if err != nil {
						err = msgp.WrapError(err, "ValidationTickets", za0001)
						return
					}
				}
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *ChallengeResponse) Msgsize() (s int) {
	s = 1 + 3 + msgp.StringPrefixSize + len(z.ID) + 18 + msgp.ArrayHeaderSize
	for za0001 := range z.ValidationTickets {
		if z.ValidationTickets[za0001] == nil {
			s += msgp.NilSize
		} else {
			s += z.ValidationTickets[za0001].Msgsize()
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *Info) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 4
	// string "Name"
	o = append(o, 0x84, 0xa4, 0x4e, 0x61, 0x6d, 0x65)
	o = msgp.AppendString(o, z.Name)
	// string "WebsiteUrl"
	o = append(o, 0xaa, 0x57, 0x65, 0x62, 0x73, 0x69, 0x74, 0x65, 0x55, 0x72, 0x6c)
	o = msgp.AppendString(o, z.WebsiteUrl)
	// string "LogoUrl"
	o = append(o, 0xa7, 0x4c, 0x6f, 0x67, 0x6f, 0x55, 0x72, 0x6c)
	o = msgp.AppendString(o, z.LogoUrl)
	// string "Description"
	o = append(o, 0xab, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e)
	o = msgp.AppendString(o, z.Description)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *Info) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "Name":
			z.Name, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Name")
				return
			}
		case "WebsiteUrl":
			z.WebsiteUrl, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "WebsiteUrl")
				return
			}
		case "LogoUrl":
			z.LogoUrl, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "LogoUrl")
				return
			}
		case "Description":
			z.Description, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Description")
				return
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *Info) Msgsize() (s int) {
	s = 1 + 5 + msgp.StringPrefixSize + len(z.Name) + 11 + msgp.StringPrefixSize + len(z.WebsiteUrl) + 8 + msgp.StringPrefixSize + len(z.LogoUrl) + 12 + msgp.StringPrefixSize + len(z.Description)
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *PriceRange) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 2
	// string "Min"
	o = append(o, 0x82, 0xa3, 0x4d, 0x69, 0x6e)
	o, err = z.Min.MarshalMsg(o)
	if err != nil {
		err = msgp.WrapError(err, "Min")
		return
	}
	// string "Max"
	o = append(o, 0xa3, 0x4d, 0x61, 0x78)
	o, err = z.Max.MarshalMsg(o)
	if err != nil {
		err = msgp.WrapError(err, "Max")
		return
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *PriceRange) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "Min":
			bts, err = z.Min.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "Min")
				return
			}
		case "Max":
			bts, err = z.Max.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "Max")
				return
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *PriceRange) Msgsize() (s int) {
	s = 1 + 4 + z.Min.Msgsize() + 4 + z.Max.Msgsize()
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *ReadConnection) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 1
	// string "ReadMarker"
	o = append(o, 0x81, 0xaa, 0x52, 0x65, 0x61, 0x64, 0x4d, 0x61, 0x72, 0x6b, 0x65, 0x72)
	if z.ReadMarker == nil {
		o = msgp.AppendNil(o)
	} else {
		o, err = z.ReadMarker.MarshalMsg(o)
		if err != nil {
			err = msgp.WrapError(err, "ReadMarker")
			return
		}
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *ReadConnection) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "ReadMarker":
			if msgp.IsNil(bts) {
				bts, err = msgp.ReadNilBytes(bts)
				if err != nil {
					return
				}
				z.ReadMarker = nil
			} else {
				if z.ReadMarker == nil {
					z.ReadMarker = new(ReadMarker)
				}
				bts, err = z.ReadMarker.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "ReadMarker")
					return
				}
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

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

// MarshalMsg implements msgp.Marshaler
func (z *ReadMarker) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 9
	// string "ClientID"
	o = append(o, 0x89, 0xa8, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x49, 0x44)
	o = msgp.AppendString(o, z.ClientID)
	// string "ClientPublicKey"
	o = append(o, 0xaf, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79)
	o = msgp.AppendString(o, z.ClientPublicKey)
	// string "BlobberID"
	o = append(o, 0xa9, 0x42, 0x6c, 0x6f, 0x62, 0x62, 0x65, 0x72, 0x49, 0x44)
	o = msgp.AppendString(o, z.BlobberID)
	// string "AllocationID"
	o = append(o, 0xac, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44)
	o = msgp.AppendString(o, z.AllocationID)
	// string "OwnerID"
	o = append(o, 0xa7, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x49, 0x44)
	o = msgp.AppendString(o, z.OwnerID)
	// string "Timestamp"
	o = append(o, 0xa9, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70)
	o, err = z.Timestamp.MarshalMsg(o)
	if err != nil {
		err = msgp.WrapError(err, "Timestamp")
		return
	}
	// string "ReadCounter"
	o = append(o, 0xab, 0x52, 0x65, 0x61, 0x64, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72)
	o = msgp.AppendInt64(o, z.ReadCounter)
	// string "Signature"
	o = append(o, 0xa9, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65)
	o = msgp.AppendString(o, z.Signature)
	// string "ReadSize"
	o = append(o, 0xa8, 0x52, 0x65, 0x61, 0x64, 0x53, 0x69, 0x7a, 0x65)
	o = msgp.AppendFloat64(o, z.ReadSize)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *ReadMarker) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "ClientID":
			z.ClientID, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ClientID")
				return
			}
		case "ClientPublicKey":
			z.ClientPublicKey, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ClientPublicKey")
				return
			}
		case "BlobberID":
			z.BlobberID, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "BlobberID")
				return
			}
		case "AllocationID":
			z.AllocationID, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "AllocationID")
				return
			}
		case "OwnerID":
			z.OwnerID, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "OwnerID")
				return
			}
		case "Timestamp":
			bts, err = z.Timestamp.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "Timestamp")
				return
			}
		case "ReadCounter":
			z.ReadCounter, bts, err = msgp.ReadInt64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ReadCounter")
				return
			}
		case "Signature":
			z.Signature, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Signature")
				return
			}
		case "ReadSize":
			z.ReadSize, bts, err = msgp.ReadFloat64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ReadSize")
				return
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *ReadMarker) Msgsize() (s int) {
	s = 1 + 9 + msgp.StringPrefixSize + len(z.ClientID) + 16 + msgp.StringPrefixSize + len(z.ClientPublicKey) + 10 + msgp.StringPrefixSize + len(z.BlobberID) + 13 + msgp.StringPrefixSize + len(z.AllocationID) + 8 + msgp.StringPrefixSize + len(z.OwnerID) + 10 + z.Timestamp.Msgsize() + 12 + msgp.Int64Size + 10 + msgp.StringPrefixSize + len(z.Signature) + 9 + msgp.Float64Size
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *RewardRound) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 2
	// string "StartRound"
	o = append(o, 0x82, 0xaa, 0x53, 0x74, 0x61, 0x72, 0x74, 0x52, 0x6f, 0x75, 0x6e, 0x64)
	o = msgp.AppendInt64(o, z.StartRound)
	// string "Timestamp"
	o = append(o, 0xa9, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70)
	o, err = z.Timestamp.MarshalMsg(o)
	if err != nil {
		err = msgp.WrapError(err, "Timestamp")
		return
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *RewardRound) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "StartRound":
			z.StartRound, bts, err = msgp.ReadInt64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "StartRound")
				return
			}
		case "Timestamp":
			bts, err = z.Timestamp.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "Timestamp")
				return
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *RewardRound) Msgsize() (s int) {
	s = 1 + 11 + msgp.Int64Size + 10 + z.Timestamp.Msgsize()
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *StorageAllocationStats) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 8
	// string "UsedSize"
	o = append(o, 0x88, 0xa8, 0x55, 0x73, 0x65, 0x64, 0x53, 0x69, 0x7a, 0x65)
	o = msgp.AppendInt64(o, z.UsedSize)
	// string "NumWrites"
	o = append(o, 0xa9, 0x4e, 0x75, 0x6d, 0x57, 0x72, 0x69, 0x74, 0x65, 0x73)
	o = msgp.AppendInt64(o, z.NumWrites)
	// string "NumReads"
	o = append(o, 0xa8, 0x4e, 0x75, 0x6d, 0x52, 0x65, 0x61, 0x64, 0x73)
	o = msgp.AppendInt64(o, z.NumReads)
	// string "TotalChallenges"
	o = append(o, 0xaf, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x43, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x73)
	o = msgp.AppendInt64(o, z.TotalChallenges)
	// string "OpenChallenges"
	o = append(o, 0xae, 0x4f, 0x70, 0x65, 0x6e, 0x43, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x73)
	o = msgp.AppendInt64(o, z.OpenChallenges)
	// string "SuccessChallenges"
	o = append(o, 0xb1, 0x53, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x43, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x73)
	o = msgp.AppendInt64(o, z.SuccessChallenges)
	// string "FailedChallenges"
	o = append(o, 0xb0, 0x46, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x43, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x73)
	o = msgp.AppendInt64(o, z.FailedChallenges)
	// string "LastestClosedChallengeTxn"
	o = append(o, 0xb9, 0x4c, 0x61, 0x73, 0x74, 0x65, 0x73, 0x74, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x43, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x54, 0x78, 0x6e)
	o = msgp.AppendString(o, z.LastestClosedChallengeTxn)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *StorageAllocationStats) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "UsedSize":
			z.UsedSize, bts, err = msgp.ReadInt64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "UsedSize")
				return
			}
		case "NumWrites":
			z.NumWrites, bts, err = msgp.ReadInt64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "NumWrites")
				return
			}
		case "NumReads":
			z.NumReads, bts, err = msgp.ReadInt64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "NumReads")
				return
			}
		case "TotalChallenges":
			z.TotalChallenges, bts, err = msgp.ReadInt64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "TotalChallenges")
				return
			}
		case "OpenChallenges":
			z.OpenChallenges, bts, err = msgp.ReadInt64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "OpenChallenges")
				return
			}
		case "SuccessChallenges":
			z.SuccessChallenges, bts, err = msgp.ReadInt64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "SuccessChallenges")
				return
			}
		case "FailedChallenges":
			z.FailedChallenges, bts, err = msgp.ReadInt64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "FailedChallenges")
				return
			}
		case "LastestClosedChallengeTxn":
			z.LastestClosedChallengeTxn, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "LastestClosedChallengeTxn")
				return
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *StorageAllocationStats) Msgsize() (s int) {
	s = 1 + 9 + msgp.Int64Size + 10 + msgp.Int64Size + 9 + msgp.Int64Size + 16 + msgp.Int64Size + 15 + msgp.Int64Size + 18 + msgp.Int64Size + 17 + msgp.Int64Size + 26 + msgp.StringPrefixSize + len(z.LastestClosedChallengeTxn)
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *StorageChallenge) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 8
	// string "Created"
	o = append(o, 0x88, 0xa7, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64)
	o, err = z.Created.MarshalMsg(o)
	if err != nil {
		err = msgp.WrapError(err, "Created")
		return
	}
	// string "ID"
	o = append(o, 0xa2, 0x49, 0x44)
	o = msgp.AppendString(o, z.ID)
	// string "TotalValidators"
	o = append(o, 0xaf, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73)
	o = msgp.AppendInt(o, z.TotalValidators)
	// string "ValidatorIDs"
	o = append(o, 0xac, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x44, 0x73)
	o = msgp.AppendArrayHeader(o, uint32(len(z.ValidatorIDs)))
	for za0001 := range z.ValidatorIDs {
		o = msgp.AppendString(o, z.ValidatorIDs[za0001])
	}
	// string "AllocationID"
	o = append(o, 0xac, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44)
	o = msgp.AppendString(o, z.AllocationID)
	// string "BlobberID"
	o = append(o, 0xa9, 0x42, 0x6c, 0x6f, 0x62, 0x62, 0x65, 0x72, 0x49, 0x44)
	o = msgp.AppendString(o, z.BlobberID)
	// string "Responded"
	o = append(o, 0xa9, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x65, 0x64)
	o = msgp.AppendInt64(o, z.Responded)
	// string "RoundCreatedAt"
	o = append(o, 0xae, 0x52, 0x6f, 0x75, 0x6e, 0x64, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74)
	o = msgp.AppendInt64(o, z.RoundCreatedAt)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *StorageChallenge) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "Created":
			bts, err = z.Created.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "Created")
				return
			}
		case "ID":
			z.ID, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ID")
				return
			}
		case "TotalValidators":
			z.TotalValidators, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "TotalValidators")
				return
			}
		case "ValidatorIDs":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ValidatorIDs")
				return
			}
			if cap(z.ValidatorIDs) >= int(zb0002) {
				z.ValidatorIDs = (z.ValidatorIDs)[:zb0002]
			} else {
				z.ValidatorIDs = make([]string, zb0002)
			}
			for za0001 := range z.ValidatorIDs {
				z.ValidatorIDs[za0001], bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "ValidatorIDs", za0001)
					return
				}
			}
		case "AllocationID":
			z.AllocationID, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "AllocationID")
				return
			}
		case "BlobberID":
			z.BlobberID, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "BlobberID")
				return
			}
		case "Responded":
			z.Responded, bts, err = msgp.ReadInt64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Responded")
				return
			}
		case "RoundCreatedAt":
			z.RoundCreatedAt, bts, err = msgp.ReadInt64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "RoundCreatedAt")
				return
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *StorageChallenge) Msgsize() (s int) {
	s = 1 + 8 + z.Created.Msgsize() + 3 + msgp.StringPrefixSize + len(z.ID) + 16 + msgp.IntSize + 13 + msgp.ArrayHeaderSize
	for za0001 := range z.ValidatorIDs {
		s += msgp.StringPrefixSize + len(z.ValidatorIDs[za0001])
	}
	s += 13 + msgp.StringPrefixSize + len(z.AllocationID) + 10 + msgp.StringPrefixSize + len(z.BlobberID) + 10 + msgp.Int64Size + 15 + msgp.Int64Size
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *StorageNodes) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 1
	// string "Nodes"
	o = append(o, 0x81, 0xa5, 0x4e, 0x6f, 0x64, 0x65, 0x73)
	o, err = z.Nodes.MarshalMsg(o)
	if err != nil {
		err = msgp.WrapError(err, "Nodes")
		return
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *StorageNodes) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "Nodes":
			bts, err = z.Nodes.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "Nodes")
				return
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

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

// MarshalMsg implements msgp.Marshaler
func (z *Terms) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 2
	// string "ReadPrice"
	o = append(o, 0x82, 0xa9, 0x52, 0x65, 0x61, 0x64, 0x50, 0x72, 0x69, 0x63, 0x65)
	o, err = z.ReadPrice.MarshalMsg(o)
	if err != nil {
		err = msgp.WrapError(err, "ReadPrice")
		return
	}
	// string "WritePrice"
	o = append(o, 0xaa, 0x57, 0x72, 0x69, 0x74, 0x65, 0x50, 0x72, 0x69, 0x63, 0x65)
	o, err = z.WritePrice.MarshalMsg(o)
	if err != nil {
		err = msgp.WrapError(err, "WritePrice")
		return
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *Terms) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "ReadPrice":
			bts, err = z.ReadPrice.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "ReadPrice")
				return
			}
		case "WritePrice":
			bts, err = z.WritePrice.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "WritePrice")
				return
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *Terms) Msgsize() (s int) {
	s = 1 + 10 + z.ReadPrice.Msgsize() + 11 + z.WritePrice.Msgsize()
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *Transfer) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 4
	// string "value"
	o = append(o, 0x84, 0xa5, 0x76, 0x61, 0x6c, 0x75, 0x65)
	o, err = z.value.MarshalMsg(o)
	if err != nil {
		err = msgp.WrapError(err, "value")
		return
	}
	// string "clientId"
	o = append(o, 0xa8, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x49, 0x64)
	o = msgp.AppendString(o, z.clientId)
	// string "toClientId"
	o = append(o, 0xaa, 0x74, 0x6f, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x49, 0x64)
	o = msgp.AppendString(o, z.toClientId)
	// string "isMint"
	o = append(o, 0xa6, 0x69, 0x73, 0x4d, 0x69, 0x6e, 0x74)
	o = msgp.AppendBool(o, z.isMint)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *Transfer) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "value":
			bts, err = z.value.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "value")
				return
			}
		case "clientId":
			z.clientId, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "clientId")
				return
			}
		case "toClientId":
			z.toClientId, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "toClientId")
				return
			}
		case "isMint":
			z.isMint, bts, err = msgp.ReadBoolBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "isMint")
				return
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *Transfer) Msgsize() (s int) {
	s = 1 + 6 + z.value.Msgsize() + 9 + msgp.StringPrefixSize + len(z.clientId) + 11 + msgp.StringPrefixSize + len(z.toClientId) + 7 + msgp.BoolSize
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *ValidationNode) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 4
	// string "Provider"
	o = append(o, 0x84, 0xa8, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72)
	o, err = z.Provider.MarshalMsg(o)
	if err != nil {
		err = msgp.WrapError(err, "Provider")
		return
	}
	// string "BaseURL"
	o = append(o, 0xa7, 0x42, 0x61, 0x73, 0x65, 0x55, 0x52, 0x4c)
	o = msgp.AppendString(o, z.BaseURL)
	// string "StakePoolSettings"
	o = append(o, 0xb1, 0x53, 0x74, 0x61, 0x6b, 0x65, 0x50, 0x6f, 0x6f, 0x6c, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73)
	o, err = z.StakePoolSettings.MarshalMsg(o)
	if err != nil {
		err = msgp.WrapError(err, "StakePoolSettings")
		return
	}
	// string "LastHealthCheck"
	o = append(o, 0xaf, 0x4c, 0x61, 0x73, 0x74, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x43, 0x68, 0x65, 0x63, 0x6b)
	o, err = z.LastHealthCheck.MarshalMsg(o)
	if err != nil {
		err = msgp.WrapError(err, "LastHealthCheck")
		return
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *ValidationNode) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "Provider":
			bts, err = z.Provider.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "Provider")
				return
			}
		case "BaseURL":
			z.BaseURL, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "BaseURL")
				return
			}
		case "StakePoolSettings":
			bts, err = z.StakePoolSettings.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "StakePoolSettings")
				return
			}
		case "LastHealthCheck":
			bts, err = z.LastHealthCheck.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "LastHealthCheck")
				return
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *ValidationNode) Msgsize() (s int) {
	s = 1 + 9 + z.Provider.Msgsize() + 8 + msgp.StringPrefixSize + len(z.BaseURL) + 18 + z.StakePoolSettings.Msgsize() + 16 + z.LastHealthCheck.Msgsize()
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *ValidationTicket) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 9
	// string "ChallengeID"
	o = append(o, 0x89, 0xab, 0x43, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x49, 0x44)
	o = msgp.AppendString(o, z.ChallengeID)
	// string "BlobberID"
	o = append(o, 0xa9, 0x42, 0x6c, 0x6f, 0x62, 0x62, 0x65, 0x72, 0x49, 0x44)
	o = msgp.AppendString(o, z.BlobberID)
	// string "ValidatorID"
	o = append(o, 0xab, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x49, 0x44)
	o = msgp.AppendString(o, z.ValidatorID)
	// string "ValidatorKey"
	o = append(o, 0xac, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x4b, 0x65, 0x79)
	o = msgp.AppendString(o, z.ValidatorKey)
	// string "Result"
	o = append(o, 0xa6, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74)
	o = msgp.AppendBool(o, z.Result)
	// string "Message"
	o = append(o, 0xa7, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65)
	o = msgp.AppendString(o, z.Message)
	// string "MessageCode"
	o = append(o, 0xab, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x43, 0x6f, 0x64, 0x65)
	o = msgp.AppendString(o, z.MessageCode)
	// string "Timestamp"
	o = append(o, 0xa9, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70)
	o, err = z.Timestamp.MarshalMsg(o)
	if err != nil {
		err = msgp.WrapError(err, "Timestamp")
		return
	}
	// string "Signature"
	o = append(o, 0xa9, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65)
	o = msgp.AppendString(o, z.Signature)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *ValidationTicket) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "ChallengeID":
			z.ChallengeID, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ChallengeID")
				return
			}
		case "BlobberID":
			z.BlobberID, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "BlobberID")
				return
			}
		case "ValidatorID":
			z.ValidatorID, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ValidatorID")
				return
			}
		case "ValidatorKey":
			z.ValidatorKey, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ValidatorKey")
				return
			}
		case "Result":
			z.Result, bts, err = msgp.ReadBoolBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Result")
				return
			}
		case "Message":
			z.Message, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Message")
				return
			}
		case "MessageCode":
			z.MessageCode, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "MessageCode")
				return
			}
		case "Timestamp":
			bts, err = z.Timestamp.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "Timestamp")
				return
			}
		case "Signature":
			z.Signature, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Signature")
				return
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *ValidationTicket) Msgsize() (s int) {
	s = 1 + 12 + msgp.StringPrefixSize + len(z.ChallengeID) + 10 + msgp.StringPrefixSize + len(z.BlobberID) + 12 + msgp.StringPrefixSize + len(z.ValidatorID) + 13 + msgp.StringPrefixSize + len(z.ValidatorKey) + 7 + msgp.BoolSize + 8 + msgp.StringPrefixSize + len(z.Message) + 12 + msgp.StringPrefixSize + len(z.MessageCode) + 10 + z.Timestamp.Msgsize() + 10 + msgp.StringPrefixSize + len(z.Signature)
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *ValidatorNodes) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 1
	// string "Nodes"
	o = append(o, 0x81, 0xa5, 0x4e, 0x6f, 0x64, 0x65, 0x73)
	o = msgp.AppendArrayHeader(o, uint32(len(z.Nodes)))
	for za0001 := range z.Nodes {
		if z.Nodes[za0001] == nil {
			o = msgp.AppendNil(o)
		} else {
			o, err = z.Nodes[za0001].MarshalMsg(o)
			if err != nil {
				err = msgp.WrapError(err, "Nodes", za0001)
				return
			}
		}
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *ValidatorNodes) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "Nodes":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Nodes")
				return
			}
			if cap(z.Nodes) >= int(zb0002) {
				z.Nodes = (z.Nodes)[:zb0002]
			} else {
				z.Nodes = make([]*ValidationNode, zb0002)
			}
			for za0001 := range z.Nodes {
				if msgp.IsNil(bts) {
					bts, err = msgp.ReadNilBytes(bts)
					if err != nil {
						return
					}
					z.Nodes[za0001] = nil
				} else {
					if z.Nodes[za0001] == nil {
						z.Nodes[za0001] = new(ValidationNode)
					}
					bts, err = z.Nodes[za0001].UnmarshalMsg(bts)
					if err != nil {
						err = msgp.WrapError(err, "Nodes", za0001)
						return
					}
				}
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *ValidatorNodes) Msgsize() (s int) {
	s = 1 + 6 + msgp.ArrayHeaderSize
	for za0001 := range z.Nodes {
		if z.Nodes[za0001] == nil {
			s += msgp.NilSize
		} else {
			s += z.Nodes[za0001].Msgsize()
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *allocationChallengesDecoder) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 2
	// string "AllocationID"
	o = append(o, 0x82, 0xac, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44)
	o = msgp.AppendString(o, z.AllocationID)
	// string "OpenChallenges"
	o = append(o, 0xae, 0x4f, 0x70, 0x65, 0x6e, 0x43, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x73)
	o = msgp.AppendArrayHeader(o, uint32(len(z.OpenChallenges)))
	for za0001 := range z.OpenChallenges {
		if z.OpenChallenges[za0001] == nil {
			o = msgp.AppendNil(o)
		} else {
			o, err = z.OpenChallenges[za0001].MarshalMsg(o)
			if err != nil {
				err = msgp.WrapError(err, "OpenChallenges", za0001)
				return
			}
		}
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *allocationChallengesDecoder) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "AllocationID":
			z.AllocationID, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "AllocationID")
				return
			}
		case "OpenChallenges":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "OpenChallenges")
				return
			}
			if cap(z.OpenChallenges) >= int(zb0002) {
				z.OpenChallenges = (z.OpenChallenges)[:zb0002]
			} else {
				z.OpenChallenges = make([]*AllocOpenChallenge, zb0002)
			}
			for za0001 := range z.OpenChallenges {
				if msgp.IsNil(bts) {
					bts, err = msgp.ReadNilBytes(bts)
					if err != nil {
						return
					}
					z.OpenChallenges[za0001] = nil
				} else {
					if z.OpenChallenges[za0001] == nil {
						z.OpenChallenges[za0001] = new(AllocOpenChallenge)
					}
					bts, err = z.OpenChallenges[za0001].UnmarshalMsg(bts)
					if err != nil {
						err = msgp.WrapError(err, "OpenChallenges", za0001)
						return
					}
				}
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *allocationChallengesDecoder) Msgsize() (s int) {
	s = 1 + 13 + msgp.StringPrefixSize + len(z.AllocationID) + 15 + msgp.ArrayHeaderSize
	for za0001 := range z.OpenChallenges {
		if z.OpenChallenges[za0001] == nil {
			s += msgp.NilSize
		} else {
			s += z.OpenChallenges[za0001].Msgsize()
		}
	}
	return
}
