frostfs-api-go/v2/service/marshal.go

package service

import (
	"encoding/binary"

	"github.com/nspcc-dev/neofs-api-go/util/proto"
)

const (
	signatureKeyField   = 1
	signatureValueField = 2

	versionMajorField = 1
	versionMinorField = 2

	xheaderKeyField   = 1
	xheaderValueField = 2

	lifetimeExpirationField     = 1
	lifetimeNotValidBeforeField = 2
	lifetimeIssuedAtField       = 3

	objectCtxVerbField    = 1
	objectCtxAddressField = 2

	sessionTokenBodyIDField        = 1
	sessionTokenBodyOwnerField     = 2
	sessionTokenBodyLifetimeField  = 3
	sessionTokenBodyKeyField       = 4
	sessionTokenBodyObjectCtxField = 5

	sessionTokenBodyField      = 1
	sessionTokenSignatureField = 2

	bearerTokenBodyACLField      = 1
	bearerTokenBodyOwnerField    = 2
	bearerTokenBodyLifetimeField = 3

	bearerTokenBodyField      = 1
	bearerTokenSignatureField = 2

	reqMetaHeaderVersionField      = 1
	reqMetaHeaderEpochField        = 2
	reqMetaHeaderTTLField          = 3
	reqMetaHeaderXHeadersField     = 4
	reqMetaHeaderSessionTokenField = 5
	reqMetaHeaderBearerTokenField  = 6
	reqMetaHeaderOriginField       = 7

	reqVerifHeaderBodySignatureField   = 1
	reqVerifHeaderMetaSignatureField   = 2
	reqVerifHeaderOriginSignatureField = 3
	reqVerifHeaderOriginField          = 4

	respMetaHeaderVersionField  = 1
	respMetaHeaderEpochField    = 2
	respMetaHeaderTTLField      = 3
	respMetaHeaderXHeadersField = 4
	respMetaHeaderOriginField   = 5

	respVerifHeaderBodySignatureField   = 1
	respVerifHeaderMetaSignatureField   = 2
	respVerifHeaderOriginSignatureField = 3
	respVerifHeaderOriginField          = 4
)

func (s *Signature) StableMarshal(buf []byte) ([]byte, error) {
	if s == nil {
		return []byte{}, nil
	}

	if buf == nil {
		buf = make([]byte, s.StableSize())
	}

	var (
		offset, n int
		err       error
	)

	n, err = proto.BytesMarshal(signatureKeyField, buf, s.key)
	if err != nil {
		return nil, err
	}

	offset += n

	_, err = proto.BytesMarshal(signatureValueField, buf[offset:], s.sign)
	if err != nil {
		return nil, err
	}

	return buf, nil
}

func (s *Signature) StableSize() (size int) {
	if s == nil {
		return 0
	}

	size += proto.BytesSize(signatureKeyField, s.key)
	size += proto.BytesSize(signatureValueField, s.sign)

	return size
}

func (v *Version) StableMarshal(buf []byte) ([]byte, error) {
	if v == nil {
		return []byte{}, nil
	}

	if buf == nil {
		buf = make([]byte, v.StableSize())
	}

	var (
		offset, n int
		err       error
	)

	n, err = proto.UInt32Marshal(versionMajorField, buf, v.major)
	if err != nil {
		return nil, err
	}

	offset += n

	_, err = proto.UInt32Marshal(versionMinorField, buf[offset:], v.minor)
	if err != nil {
		return nil, err
	}

	return buf, nil
}

func (v *Version) StableSize() (size int) {
	if v == nil {
		return 0
	}

	size += proto.UInt32Size(versionMajorField, v.major)
	size += proto.UInt32Size(versionMinorField, v.minor)

	return size
}

func (x *XHeader) StableMarshal(buf []byte) ([]byte, error) {
	if x == nil {
		return []byte{}, nil
	}

	if buf == nil {
		buf = make([]byte, x.StableSize())
	}

	var (
		offset, n int
		err       error
	)

	n, err = proto.StringMarshal(xheaderKeyField, buf, x.key)
	if err != nil {
		return nil, err
	}

	offset += n

	_, err = proto.StringMarshal(xheaderValueField, buf[offset:], x.val)
	if err != nil {
		return nil, err
	}

	return buf, nil
}

func (x *XHeader) StableSize() (size int) {
	if x == nil {
		return 0
	}

	size += proto.StringSize(xheaderKeyField, x.key)
	size += proto.StringSize(xheaderValueField, x.val)

	return size
}

func (l *TokenLifetime) StableMarshal(buf []byte) ([]byte, error) {
	if l == nil {
		return []byte{}, nil
	}

	if buf == nil {
		buf = make([]byte, l.StableSize())
	}

	var (
		offset, n int
		err       error
	)

	n, err = proto.UInt64Marshal(lifetimeExpirationField, buf, l.exp)
	if err != nil {
		return nil, err
	}

	offset += n

	n, err = proto.UInt64Marshal(lifetimeNotValidBeforeField, buf[offset:], l.nbf)
	if err != nil {
		return nil, err
	}

	offset += n

	_, err = proto.UInt64Marshal(lifetimeIssuedAtField, buf[offset:], l.iat)
	if err != nil {
		return nil, err
	}

	return buf, nil
}

func (l *TokenLifetime) StableSize() (size int) {
	if l == nil {
		return 0
	}

	size += proto.UInt64Size(lifetimeExpirationField, l.exp)
	size += proto.UInt64Size(lifetimeNotValidBeforeField, l.nbf)
	size += proto.UInt64Size(lifetimeIssuedAtField, l.iat)

	return size
}

func (c *ObjectSessionContext) StableMarshal(buf []byte) ([]byte, error) {
	if c == nil {
		return []byte{}, nil
	}

	if buf == nil {
		buf = make([]byte, c.StableSize())
	}

	var (
		offset, n int
		prefix    uint64
		err       error
	)

	n, err = proto.EnumMarshal(objectCtxVerbField, buf, int32(c.verb))
	if err != nil {
		return nil, err
	}

	offset += n

	if c.addr != nil {
		prefix, _ = proto.NestedStructurePrefix(objectCtxAddressField)
		offset += binary.PutUvarint(buf[offset:], prefix)

		n = c.addr.StableSize()
		offset += binary.PutUvarint(buf[offset:], uint64(n))

		_, err = c.addr.StableMarshal(buf[offset:])
		if err != nil {
			return nil, err

		}
	}

	return buf, nil
}

func (c *ObjectSessionContext) StableSize() (size int) {
	if c == nil {
		return 0
	}

	size += proto.EnumSize(objectCtxVerbField, int32(c.verb))

	if c.addr != nil {
		_, ln := proto.NestedStructurePrefix(objectCtxAddressField)
		n := c.addr.StableSize()
		size += ln + proto.VarUIntSize(uint64(n)) + n
	}

	return size
}

func (t *SessionTokenBody) StableMarshal(buf []byte) ([]byte, error) {
	if t == nil {
		return []byte{}, nil
	}

	if buf == nil {
		buf = make([]byte, t.StableSize())
	}

	var (
		offset, n int
		prefix    uint64
		err       error
	)

	n, err = proto.BytesMarshal(sessionTokenBodyIDField, buf, t.id)
	if err != nil {
		return nil, err
	}

	offset += n

	if t.ownerID != nil {
		prefix, _ = proto.NestedStructurePrefix(sessionTokenBodyOwnerField)
		offset += binary.PutUvarint(buf[offset:], prefix)

		n = t.ownerID.StableSize()
		offset += binary.PutUvarint(buf[offset:], uint64(n))

		_, err = t.ownerID.StableMarshal(buf[offset:])
		if err != nil {
			return nil, err

		}

		offset += n
	}

	if t.lifetime != nil {
		prefix, _ = proto.NestedStructurePrefix(sessionTokenBodyLifetimeField)
		offset += binary.PutUvarint(buf[offset:], prefix)

		n = t.lifetime.StableSize()
		offset += binary.PutUvarint(buf[offset:], uint64(n))

		_, err = t.lifetime.StableMarshal(buf[offset:])
		if err != nil {
			return nil, err

		}

		offset += n
	}

	n, err = proto.BytesMarshal(sessionTokenBodyKeyField, buf[offset:], t.sessionKey)
	if err != nil {
		return nil, err
	}

	offset += n

	if t.ctx != nil {
		switch v := t.ctx.(type) {
		case *ObjectSessionContext:
			prefix, _ = proto.NestedStructurePrefix(sessionTokenBodyObjectCtxField)
			offset += binary.PutUvarint(buf[offset:], prefix)

			n = v.StableSize()
			offset += binary.PutUvarint(buf[offset:], uint64(n))

			_, err = v.StableMarshal(buf[offset:])
			if err != nil {
				return nil, err

			}
		default:
			panic("cannot marshal unknown session token context")
		}
	}

	return buf, nil
}

func (t *SessionTokenBody) StableSize() (size int) {
	if t == nil {
		return 0
	}

	size += proto.BytesSize(sessionTokenBodyIDField, t.id)

	if t.ownerID != nil {
		_, ln := proto.NestedStructurePrefix(sessionTokenBodyOwnerField)
		n := t.ownerID.StableSize()
		size += ln + proto.VarUIntSize(uint64(n)) + n
	}

	if t.lifetime != nil {
		_, ln := proto.NestedStructurePrefix(sessionTokenBodyLifetimeField)
		n := t.lifetime.StableSize()
		size += ln + proto.VarUIntSize(uint64(n)) + n
	}

	size += proto.BytesSize(sessionTokenBodyKeyField, t.sessionKey)

	if t.ctx != nil {
		switch v := t.ctx.(type) {
		case *ObjectSessionContext:
			_, ln := proto.NestedStructurePrefix(sessionTokenBodyObjectCtxField)
			n := v.StableSize()
			size += ln + proto.VarUIntSize(uint64(n)) + n
		default:
			panic("cannot marshal unknown session token context")
		}
	}

	return size
}

func (t *SessionToken) StableMarshal(buf []byte) ([]byte, error) {
	if t == nil {
		return []byte{}, nil
	}

	if buf == nil {
		buf = make([]byte, t.StableSize())
	}

	var (
		offset, n int
		prefix    uint64
		err       error
	)

	if t.body != nil {
		prefix, _ = proto.NestedStructurePrefix(sessionTokenBodyField)
		offset += binary.PutUvarint(buf[offset:], prefix)

		n = t.body.StableSize()
		offset += binary.PutUvarint(buf[offset:], uint64(n))

		_, err = t.body.StableMarshal(buf[offset:])
		if err != nil {
			return nil, err

		}

		offset += n
	}

	if t.sig != nil {
		prefix, _ = proto.NestedStructurePrefix(sessionTokenSignatureField)
		offset += binary.PutUvarint(buf[offset:], prefix)

		n = t.sig.StableSize()
		offset += binary.PutUvarint(buf[offset:], uint64(n))

		_, err = t.sig.StableMarshal(buf[offset:])
		if err != nil {
			return nil, err

		}
	}

	return buf, nil
}

func (t *SessionToken) StableSize() (size int) {
	if t == nil {
		return 0
	}

	if t.body != nil {
		_, ln := proto.NestedStructurePrefix(sessionTokenBodyField)
		n := t.body.StableSize()
		size += ln + proto.VarUIntSize(uint64(n)) + n
	}

	if t.sig != nil {
		_, ln := proto.NestedStructurePrefix(sessionTokenSignatureField)
		n := t.sig.StableSize()
		size += ln + proto.VarUIntSize(uint64(n)) + n
	}

	return size
}

func (bt *BearerTokenBody) StableMarshal(buf []byte) ([]byte, error) {
	if bt == nil {
		return []byte{}, nil
	}

	if buf == nil {
		buf = make([]byte, bt.StableSize())
	}

	var (
		offset, n int
		prefix    uint64
		err       error
	)

	if bt.eacl != nil {
		prefix, _ = proto.NestedStructurePrefix(bearerTokenBodyACLField)
		offset += binary.PutUvarint(buf[offset:], prefix)

		n = bt.eacl.StableSize()
		offset += binary.PutUvarint(buf[offset:], uint64(n))

		_, err = bt.eacl.StableMarshal(buf[offset:])
		if err != nil {
			return nil, err

		}

		offset += n
	}

	if bt.ownerID != nil {
		prefix, _ = proto.NestedStructurePrefix(bearerTokenBodyOwnerField)
		offset += binary.PutUvarint(buf[offset:], prefix)

		n = bt.ownerID.StableSize()
		offset += binary.PutUvarint(buf[offset:], uint64(n))

		_, err = bt.ownerID.StableMarshal(buf[offset:])
		if err != nil {
			return nil, err

		}

		offset += n
	}

	if bt.lifetime != nil {
		prefix, _ = proto.NestedStructurePrefix(bearerTokenBodyLifetimeField)
		offset += binary.PutUvarint(buf[offset:], prefix)

		n = bt.lifetime.StableSize()
		offset += binary.PutUvarint(buf[offset:], uint64(n))

		_, err = bt.lifetime.StableMarshal(buf[offset:])
		if err != nil {
			return nil, err

		}
	}

	return buf, nil
}

func (bt *BearerTokenBody) StableSize() (size int) {
	if bt == nil {
		return 0
	}

	if bt.eacl != nil {
		_, ln := proto.NestedStructurePrefix(bearerTokenBodyACLField)
		n := bt.eacl.StableSize()
		size += ln + proto.VarUIntSize(uint64(n)) + n
	}

	if bt.ownerID != nil {
		_, ln := proto.NestedStructurePrefix(bearerTokenBodyOwnerField)
		n := bt.ownerID.StableSize()
		size += ln + proto.VarUIntSize(uint64(n)) + n
	}

	if bt.lifetime != nil {
		_, ln := proto.NestedStructurePrefix(bearerTokenBodyLifetimeField)
		n := bt.lifetime.StableSize()
		size += ln + proto.VarUIntSize(uint64(n)) + n
	}

	return size
}

func (bt *BearerToken) StableMarshal(buf []byte) ([]byte, error) {
	if bt == nil {
		return []byte{}, nil
	}

	if buf == nil {
		buf = make([]byte, bt.StableSize())
	}

	var (
		offset, n int
		prefix    uint64
		err       error
	)

	if bt.body != nil {
		prefix, _ = proto.NestedStructurePrefix(bearerTokenBodyField)
		offset += binary.PutUvarint(buf[offset:], prefix)

		n = bt.body.StableSize()
		offset += binary.PutUvarint(buf[offset:], uint64(n))

		_, err = bt.body.StableMarshal(buf[offset:])
		if err != nil {
			return nil, err

		}

		offset += n
	}

	if bt.sig != nil {
		prefix, _ = proto.NestedStructurePrefix(bearerTokenSignatureField)
		offset += binary.PutUvarint(buf[offset:], prefix)

		n = bt.sig.StableSize()
		offset += binary.PutUvarint(buf[offset:], uint64(n))

		_, err = bt.sig.StableMarshal(buf[offset:])
		if err != nil {
			return nil, err

		}
	}

	return buf, nil
}

func (bt *BearerToken) StableSize() (size int) {
	if bt == nil {
		return 0
	}

	if bt.body != nil {
		_, ln := proto.NestedStructurePrefix(bearerTokenBodyField)
		n := bt.body.StableSize()
		size += ln + proto.VarUIntSize(uint64(n)) + n
	}

	if bt.sig != nil {
		_, ln := proto.NestedStructurePrefix(bearerTokenSignatureField)
		n := bt.sig.StableSize()
		size += ln + proto.VarUIntSize(uint64(n)) + n
	}

	return size
}

func (r *RequestMetaHeader) StableMarshal(buf []byte) ([]byte, error) {
	if r == nil {
		return []byte{}, nil
	}

	if buf == nil {
		buf = make([]byte, r.StableSize())
	}

	var (
		offset, n int
		prefix    uint64
		err       error
	)

	if r.version != nil {
		prefix, _ = proto.NestedStructurePrefix(reqMetaHeaderVersionField)
		offset += binary.PutUvarint(buf[offset:], prefix)

		n = r.version.StableSize()
		offset += binary.PutUvarint(buf[offset:], uint64(n))

		_, err = r.version.StableMarshal(buf[offset:])
		if err != nil {
			return nil, err

		}

		offset += n
	}

	n, err = proto.UInt64Marshal(reqMetaHeaderEpochField, buf[offset:], r.epoch)
	if err != nil {
		return nil, err
	}

	offset += n

	n, err = proto.UInt32Marshal(reqMetaHeaderTTLField, buf[offset:], r.ttl)
	if err != nil {
		return nil, err
	}

	offset += n

	prefix, _ = proto.NestedStructurePrefix(reqMetaHeaderXHeadersField)

	for i := range r.xHeaders {
		offset += binary.PutUvarint(buf[offset:], prefix)

		n = r.xHeaders[i].StableSize()
		offset += binary.PutUvarint(buf[offset:], uint64(n))

		_, err = r.xHeaders[i].StableMarshal(buf[offset:])
		if err != nil {
			return nil, err

		}

		offset += n
	}

	if r.sessionToken != nil {
		prefix, _ = proto.NestedStructurePrefix(reqMetaHeaderSessionTokenField)
		offset += binary.PutUvarint(buf[offset:], prefix)

		n = r.sessionToken.StableSize()
		offset += binary.PutUvarint(buf[offset:], uint64(n))

		_, err = r.sessionToken.StableMarshal(buf[offset:])
		if err != nil {
			return nil, err

		}

		offset += n
	}

	if r.bearerToken != nil {
		prefix, _ = proto.NestedStructurePrefix(reqMetaHeaderBearerTokenField)
		offset += binary.PutUvarint(buf[offset:], prefix)

		n = r.bearerToken.StableSize()
		offset += binary.PutUvarint(buf[offset:], uint64(n))

		_, err = r.bearerToken.StableMarshal(buf[offset:])
		if err != nil {
			return nil, err

		}

		offset += n
	}

	if r.origin != nil {
		prefix, _ = proto.NestedStructurePrefix(reqMetaHeaderOriginField)
		offset += binary.PutUvarint(buf[offset:], prefix)

		n = r.origin.StableSize()
		offset += binary.PutUvarint(buf[offset:], uint64(n))

		_, err = r.origin.StableMarshal(buf[offset:])
		if err != nil {
			return nil, err

		}
	}

	return buf, nil
}

func (r *RequestMetaHeader) StableSize() (size int) {
	if r == nil {
		return 0
	}

	if r.version != nil {
		_, ln := proto.NestedStructurePrefix(reqMetaHeaderVersionField)
		n := r.version.StableSize()
		size += ln + proto.VarUIntSize(uint64(n)) + n
	}

	size += proto.UInt64Size(reqMetaHeaderEpochField, r.epoch)
	size += proto.UInt32Size(reqMetaHeaderTTLField, r.ttl)

	_, ln := proto.NestedStructurePrefix(reqMetaHeaderXHeadersField)

	for i := range r.xHeaders {
		n := r.xHeaders[i].StableSize()
		size += ln + proto.VarUIntSize(uint64(n)) + n
	}

	if r.sessionToken != nil {
		_, ln := proto.NestedStructurePrefix(reqMetaHeaderSessionTokenField)
		n := r.sessionToken.StableSize()
		size += ln + proto.VarUIntSize(uint64(n)) + n
	}

	if r.bearerToken != nil {
		_, ln := proto.NestedStructurePrefix(reqMetaHeaderBearerTokenField)
		n := r.bearerToken.StableSize()
		size += ln + proto.VarUIntSize(uint64(n)) + n
	}

	if r.origin != nil {
		_, ln := proto.NestedStructurePrefix(reqMetaHeaderOriginField)
		n := r.origin.StableSize()
		size += ln + proto.VarUIntSize(uint64(n)) + n
	}

	return size
}

func (r *RequestVerificationHeader) StableMarshal(buf []byte) ([]byte, error) {
	if r == nil {
		return []byte{}, nil
	}

	if buf == nil {
		buf = make([]byte, r.StableSize())
	}

	var (
		offset, n int
		prefix    uint64
		err       error
	)

	if r.bodySig != nil {
		prefix, _ = proto.NestedStructurePrefix(reqVerifHeaderBodySignatureField)
		offset += binary.PutUvarint(buf[offset:], prefix)

		n = r.bodySig.StableSize()
		offset += binary.PutUvarint(buf[offset:], uint64(n))

		_, err = r.bodySig.StableMarshal(buf[offset:])
		if err != nil {
			return nil, err

		}

		offset += n
	}

	if r.metaSig != nil {
		prefix, _ = proto.NestedStructurePrefix(reqVerifHeaderMetaSignatureField)
		offset += binary.PutUvarint(buf[offset:], prefix)

		n = r.metaSig.StableSize()
		offset += binary.PutUvarint(buf[offset:], uint64(n))

		_, err = r.metaSig.StableMarshal(buf[offset:])
		if err != nil {
			return nil, err

		}

		offset += n
	}

	if r.originSig != nil {
		prefix, _ = proto.NestedStructurePrefix(reqVerifHeaderOriginSignatureField)
		offset += binary.PutUvarint(buf[offset:], prefix)

		n = r.originSig.StableSize()
		offset += binary.PutUvarint(buf[offset:], uint64(n))

		_, err = r.originSig.StableMarshal(buf[offset:])
		if err != nil {
			return nil, err

		}

		offset += n
	}

	if r.origin != nil {
		prefix, _ = proto.NestedStructurePrefix(reqVerifHeaderOriginField)
		offset += binary.PutUvarint(buf[offset:], prefix)

		n = r.origin.StableSize()
		offset += binary.PutUvarint(buf[offset:], uint64(n))

		_, err = r.origin.StableMarshal(buf[offset:])
		if err != nil {
			return nil, err

		}
	}

	return buf, nil
}

func (r *RequestVerificationHeader) StableSize() (size int) {
	if r == nil {
		return 0
	}

	if r.bodySig != nil {
		_, ln := proto.NestedStructurePrefix(reqVerifHeaderBodySignatureField)
		n := r.bodySig.StableSize()
		size += ln + proto.VarUIntSize(uint64(n)) + n
	}

	if r.metaSig != nil {
		_, ln := proto.NestedStructurePrefix(reqVerifHeaderMetaSignatureField)
		n := r.metaSig.StableSize()
		size += ln + proto.VarUIntSize(uint64(n)) + n
	}

	if r.originSig != nil {
		_, ln := proto.NestedStructurePrefix(reqVerifHeaderOriginSignatureField)
		n := r.originSig.StableSize()
		size += ln + proto.VarUIntSize(uint64(n)) + n
	}

	if r.origin != nil {
		_, ln := proto.NestedStructurePrefix(reqVerifHeaderOriginField)
		n := r.origin.StableSize()
		size += ln + proto.VarUIntSize(uint64(n)) + n
	}

	return size
}

func (r *ResponseMetaHeader) StableMarshal(buf []byte) ([]byte, error) {
	if r == nil {
		return []byte{}, nil
	}

	if buf == nil {
		buf = make([]byte, r.StableSize())
	}

	var (
		offset, n int
		prefix    uint64
		err       error
	)

	if r.version != nil {
		prefix, _ = proto.NestedStructurePrefix(respMetaHeaderVersionField)
		offset += binary.PutUvarint(buf[offset:], prefix)

		n = r.version.StableSize()
		offset += binary.PutUvarint(buf[offset:], uint64(n))

		_, err = r.version.StableMarshal(buf[offset:])
		if err != nil {
			return nil, err

		}

		offset += n
	}

	n, err = proto.UInt64Marshal(respMetaHeaderEpochField, buf[offset:], r.epoch)
	if err != nil {
		return nil, err
	}

	offset += n

	n, err = proto.UInt32Marshal(respMetaHeaderTTLField, buf[offset:], r.ttl)
	if err != nil {
		return nil, err
	}

	offset += n

	prefix, _ = proto.NestedStructurePrefix(respMetaHeaderXHeadersField)

	for i := range r.xHeaders {
		offset += binary.PutUvarint(buf[offset:], prefix)

		n = r.xHeaders[i].StableSize()
		offset += binary.PutUvarint(buf[offset:], uint64(n))

		_, err = r.xHeaders[i].StableMarshal(buf[offset:])
		if err != nil {
			return nil, err

		}

		offset += n
	}

	if r.origin != nil {
		prefix, _ = proto.NestedStructurePrefix(respMetaHeaderOriginField)
		offset += binary.PutUvarint(buf[offset:], prefix)

		n = r.origin.StableSize()
		offset += binary.PutUvarint(buf[offset:], uint64(n))

		_, err = r.origin.StableMarshal(buf[offset:])
		if err != nil {
			return nil, err

		}
	}

	return buf, nil
}

func (r *ResponseMetaHeader) StableSize() (size int) {
	if r == nil {
		return 0
	}

	if r.version != nil {
		_, ln := proto.NestedStructurePrefix(respMetaHeaderVersionField)
		n := r.version.StableSize()
		size += ln + proto.VarUIntSize(uint64(n)) + n
	}

	size += proto.UInt64Size(respMetaHeaderEpochField, r.epoch)
	size += proto.UInt32Size(respMetaHeaderTTLField, r.ttl)

	_, ln := proto.NestedStructurePrefix(respMetaHeaderXHeadersField)

	for i := range r.xHeaders {
		n := r.xHeaders[i].StableSize()
		size += ln + proto.VarUIntSize(uint64(n)) + n
	}

	if r.origin != nil {
		_, ln := proto.NestedStructurePrefix(respMetaHeaderOriginField)
		n := r.origin.StableSize()
		size += ln + proto.VarUIntSize(uint64(n)) + n
	}

	return size
}

func (r *ResponseVerificationHeader) StableMarshal(buf []byte) ([]byte, error) {
	if r == nil {
		return []byte{}, nil
	}

	if buf == nil {
		buf = make([]byte, r.StableSize())
	}

	var (
		offset, n int
		prefix    uint64
		err       error
	)

	if r.bodySig != nil {
		prefix, _ = proto.NestedStructurePrefix(respVerifHeaderBodySignatureField)
		offset += binary.PutUvarint(buf[offset:], prefix)

		n = r.bodySig.StableSize()
		offset += binary.PutUvarint(buf[offset:], uint64(n))

		_, err = r.bodySig.StableMarshal(buf[offset:])
		if err != nil {
			return nil, err

		}

		offset += n
	}

	if r.metaSig != nil {
		prefix, _ = proto.NestedStructurePrefix(respVerifHeaderMetaSignatureField)
		offset += binary.PutUvarint(buf[offset:], prefix)

		n = r.metaSig.StableSize()
		offset += binary.PutUvarint(buf[offset:], uint64(n))

		_, err = r.metaSig.StableMarshal(buf[offset:])
		if err != nil {
			return nil, err

		}

		offset += n
	}

	if r.originSig != nil {
		prefix, _ = proto.NestedStructurePrefix(respVerifHeaderOriginSignatureField)
		offset += binary.PutUvarint(buf[offset:], prefix)

		n = r.originSig.StableSize()
		offset += binary.PutUvarint(buf[offset:], uint64(n))

		_, err = r.originSig.StableMarshal(buf[offset:])
		if err != nil {
			return nil, err

		}

		offset += n
	}

	if r.origin != nil {
		prefix, _ = proto.NestedStructurePrefix(respVerifHeaderOriginField)
		offset += binary.PutUvarint(buf[offset:], prefix)

		n = r.origin.StableSize()
		offset += binary.PutUvarint(buf[offset:], uint64(n))

		_, err = r.origin.StableMarshal(buf[offset:])
		if err != nil {
			return nil, err

		}
	}

	return buf, nil
}

func (r *ResponseVerificationHeader) StableSize() (size int) {
	if r == nil {
		return 0
	}

	if r.bodySig != nil {
		_, ln := proto.NestedStructurePrefix(respVerifHeaderBodySignatureField)
		n := r.bodySig.StableSize()
		size += ln + proto.VarUIntSize(uint64(n)) + n
	}

	if r.metaSig != nil {
		_, ln := proto.NestedStructurePrefix(respVerifHeaderMetaSignatureField)
		n := r.metaSig.StableSize()
		size += ln + proto.VarUIntSize(uint64(n)) + n
	}

	if r.originSig != nil {
		_, ln := proto.NestedStructurePrefix(respVerifHeaderOriginSignatureField)
		n := r.originSig.StableSize()
		size += ln + proto.VarUIntSize(uint64(n)) + n
	}

	if r.origin != nil {
		_, ln := proto.NestedStructurePrefix(respVerifHeaderOriginField)
		n := r.origin.StableSize()
		size += ln + proto.VarUIntSize(uint64(n)) + n
	}

	return size
}