mirror of
https://github.com/OffchainLabs/prysm.git
synced 2026-01-08 23:18:15 -05:00
e1117a7de2
* Add vectorInfo * Add 2D bytes field for test * Add tag_parser for parsing SSZ tags * Integrate tag parser with analyzer * Add ByteList test case * Changelog * Better printing feature with Stringer implementation * Return error for non-determined case without printing other values * Update tag_parser.go: handle Vector and List mutually exclusive (inspired by OffchainLabs/fastssz) * Make linter happy --------- Co-authored-by: Radosław Kapka <rkapka@wp.pl>
683 lines
16 KiB
Go
683 lines
16 KiB
Go
// Code generated by fastssz. DO NOT EDIT.
|
|
package ssz_query
|
|
|
|
import (
|
|
ssz "github.com/prysmaticlabs/fastssz"
|
|
)
|
|
|
|
// MarshalSSZ ssz marshals the FixedNestedContainer object
|
|
func (f *FixedNestedContainer) MarshalSSZ() ([]byte, error) {
|
|
return ssz.MarshalSSZ(f)
|
|
}
|
|
|
|
// MarshalSSZTo ssz marshals the FixedNestedContainer object to a target array
|
|
func (f *FixedNestedContainer) MarshalSSZTo(buf []byte) (dst []byte, err error) {
|
|
dst = buf
|
|
|
|
// Field (0) 'Value1'
|
|
dst = ssz.MarshalUint64(dst, f.Value1)
|
|
|
|
// Field (1) 'Value2'
|
|
if size := len(f.Value2); size != 32 {
|
|
err = ssz.ErrBytesLengthFn("--.Value2", size, 32)
|
|
return
|
|
}
|
|
dst = append(dst, f.Value2...)
|
|
|
|
return
|
|
}
|
|
|
|
// UnmarshalSSZ ssz unmarshals the FixedNestedContainer object
|
|
func (f *FixedNestedContainer) UnmarshalSSZ(buf []byte) error {
|
|
var err error
|
|
size := uint64(len(buf))
|
|
if size != 40 {
|
|
return ssz.ErrSize
|
|
}
|
|
|
|
// Field (0) 'Value1'
|
|
f.Value1 = ssz.UnmarshallUint64(buf[0:8])
|
|
|
|
// Field (1) 'Value2'
|
|
if cap(f.Value2) == 0 {
|
|
f.Value2 = make([]byte, 0, len(buf[8:40]))
|
|
}
|
|
f.Value2 = append(f.Value2, buf[8:40]...)
|
|
|
|
return err
|
|
}
|
|
|
|
// SizeSSZ returns the ssz encoded size in bytes for the FixedNestedContainer object
|
|
func (f *FixedNestedContainer) SizeSSZ() (size int) {
|
|
size = 40
|
|
return
|
|
}
|
|
|
|
// HashTreeRoot ssz hashes the FixedNestedContainer object
|
|
func (f *FixedNestedContainer) HashTreeRoot() ([32]byte, error) {
|
|
return ssz.HashWithDefaultHasher(f)
|
|
}
|
|
|
|
// HashTreeRootWith ssz hashes the FixedNestedContainer object with a hasher
|
|
func (f *FixedNestedContainer) HashTreeRootWith(hh *ssz.Hasher) (err error) {
|
|
indx := hh.Index()
|
|
|
|
// Field (0) 'Value1'
|
|
hh.PutUint64(f.Value1)
|
|
|
|
// Field (1) 'Value2'
|
|
if size := len(f.Value2); size != 32 {
|
|
err = ssz.ErrBytesLengthFn("--.Value2", size, 32)
|
|
return
|
|
}
|
|
hh.PutBytes(f.Value2)
|
|
|
|
hh.Merkleize(indx)
|
|
return
|
|
}
|
|
|
|
// MarshalSSZ ssz marshals the FixedTestContainer object
|
|
func (f *FixedTestContainer) MarshalSSZ() ([]byte, error) {
|
|
return ssz.MarshalSSZ(f)
|
|
}
|
|
|
|
// MarshalSSZTo ssz marshals the FixedTestContainer object to a target array
|
|
func (f *FixedTestContainer) MarshalSSZTo(buf []byte) (dst []byte, err error) {
|
|
dst = buf
|
|
|
|
// Field (0) 'FieldUint32'
|
|
dst = ssz.MarshalUint32(dst, f.FieldUint32)
|
|
|
|
// Field (1) 'FieldUint64'
|
|
dst = ssz.MarshalUint64(dst, f.FieldUint64)
|
|
|
|
// Field (2) 'FieldBool'
|
|
dst = ssz.MarshalBool(dst, f.FieldBool)
|
|
|
|
// Field (3) 'FieldBytes32'
|
|
if size := len(f.FieldBytes32); size != 32 {
|
|
err = ssz.ErrBytesLengthFn("--.FieldBytes32", size, 32)
|
|
return
|
|
}
|
|
dst = append(dst, f.FieldBytes32...)
|
|
|
|
// Field (4) 'Nested'
|
|
if f.Nested == nil {
|
|
f.Nested = new(FixedNestedContainer)
|
|
}
|
|
if dst, err = f.Nested.MarshalSSZTo(dst); err != nil {
|
|
return
|
|
}
|
|
|
|
// Field (5) 'VectorField'
|
|
if size := len(f.VectorField); size != 24 {
|
|
err = ssz.ErrVectorLengthFn("--.VectorField", size, 24)
|
|
return
|
|
}
|
|
for ii := 0; ii < 24; ii++ {
|
|
dst = ssz.MarshalUint64(dst, f.VectorField[ii])
|
|
}
|
|
|
|
// Field (6) 'TwoDimensionBytesField'
|
|
if size := len(f.TwoDimensionBytesField); size != 5 {
|
|
err = ssz.ErrVectorLengthFn("--.TwoDimensionBytesField", size, 5)
|
|
return
|
|
}
|
|
for ii := 0; ii < 5; ii++ {
|
|
if size := len(f.TwoDimensionBytesField[ii]); size != 32 {
|
|
err = ssz.ErrBytesLengthFn("--.TwoDimensionBytesField[ii]", size, 32)
|
|
return
|
|
}
|
|
dst = append(dst, f.TwoDimensionBytesField[ii]...)
|
|
}
|
|
|
|
// Field (7) 'TrailingField'
|
|
if size := len(f.TrailingField); size != 56 {
|
|
err = ssz.ErrBytesLengthFn("--.TrailingField", size, 56)
|
|
return
|
|
}
|
|
dst = append(dst, f.TrailingField...)
|
|
|
|
return
|
|
}
|
|
|
|
// UnmarshalSSZ ssz unmarshals the FixedTestContainer object
|
|
func (f *FixedTestContainer) UnmarshalSSZ(buf []byte) error {
|
|
var err error
|
|
size := uint64(len(buf))
|
|
if size != 493 {
|
|
return ssz.ErrSize
|
|
}
|
|
|
|
// Field (0) 'FieldUint32'
|
|
f.FieldUint32 = ssz.UnmarshallUint32(buf[0:4])
|
|
|
|
// Field (1) 'FieldUint64'
|
|
f.FieldUint64 = ssz.UnmarshallUint64(buf[4:12])
|
|
|
|
// Field (2) 'FieldBool'
|
|
f.FieldBool, err = ssz.DecodeBool(buf[12:13])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// Field (3) 'FieldBytes32'
|
|
if cap(f.FieldBytes32) == 0 {
|
|
f.FieldBytes32 = make([]byte, 0, len(buf[13:45]))
|
|
}
|
|
f.FieldBytes32 = append(f.FieldBytes32, buf[13:45]...)
|
|
|
|
// Field (4) 'Nested'
|
|
if f.Nested == nil {
|
|
f.Nested = new(FixedNestedContainer)
|
|
}
|
|
if err = f.Nested.UnmarshalSSZ(buf[45:85]); err != nil {
|
|
return err
|
|
}
|
|
|
|
// Field (5) 'VectorField'
|
|
f.VectorField = ssz.ExtendUint64(f.VectorField, 24)
|
|
for ii := 0; ii < 24; ii++ {
|
|
f.VectorField[ii] = ssz.UnmarshallUint64(buf[85:277][ii*8 : (ii+1)*8])
|
|
}
|
|
|
|
// Field (6) 'TwoDimensionBytesField'
|
|
f.TwoDimensionBytesField = make([][]byte, 5)
|
|
for ii := 0; ii < 5; ii++ {
|
|
if cap(f.TwoDimensionBytesField[ii]) == 0 {
|
|
f.TwoDimensionBytesField[ii] = make([]byte, 0, len(buf[277:437][ii*32:(ii+1)*32]))
|
|
}
|
|
f.TwoDimensionBytesField[ii] = append(f.TwoDimensionBytesField[ii], buf[277:437][ii*32:(ii+1)*32]...)
|
|
}
|
|
|
|
// Field (7) 'TrailingField'
|
|
if cap(f.TrailingField) == 0 {
|
|
f.TrailingField = make([]byte, 0, len(buf[437:493]))
|
|
}
|
|
f.TrailingField = append(f.TrailingField, buf[437:493]...)
|
|
|
|
return err
|
|
}
|
|
|
|
// SizeSSZ returns the ssz encoded size in bytes for the FixedTestContainer object
|
|
func (f *FixedTestContainer) SizeSSZ() (size int) {
|
|
size = 493
|
|
return
|
|
}
|
|
|
|
// HashTreeRoot ssz hashes the FixedTestContainer object
|
|
func (f *FixedTestContainer) HashTreeRoot() ([32]byte, error) {
|
|
return ssz.HashWithDefaultHasher(f)
|
|
}
|
|
|
|
// HashTreeRootWith ssz hashes the FixedTestContainer object with a hasher
|
|
func (f *FixedTestContainer) HashTreeRootWith(hh *ssz.Hasher) (err error) {
|
|
indx := hh.Index()
|
|
|
|
// Field (0) 'FieldUint32'
|
|
hh.PutUint32(f.FieldUint32)
|
|
|
|
// Field (1) 'FieldUint64'
|
|
hh.PutUint64(f.FieldUint64)
|
|
|
|
// Field (2) 'FieldBool'
|
|
hh.PutBool(f.FieldBool)
|
|
|
|
// Field (3) 'FieldBytes32'
|
|
if size := len(f.FieldBytes32); size != 32 {
|
|
err = ssz.ErrBytesLengthFn("--.FieldBytes32", size, 32)
|
|
return
|
|
}
|
|
hh.PutBytes(f.FieldBytes32)
|
|
|
|
// Field (4) 'Nested'
|
|
if err = f.Nested.HashTreeRootWith(hh); err != nil {
|
|
return
|
|
}
|
|
|
|
// Field (5) 'VectorField'
|
|
{
|
|
if size := len(f.VectorField); size != 24 {
|
|
err = ssz.ErrVectorLengthFn("--.VectorField", size, 24)
|
|
return
|
|
}
|
|
subIndx := hh.Index()
|
|
for _, i := range f.VectorField {
|
|
hh.AppendUint64(i)
|
|
}
|
|
hh.Merkleize(subIndx)
|
|
}
|
|
|
|
// Field (6) 'TwoDimensionBytesField'
|
|
{
|
|
if size := len(f.TwoDimensionBytesField); size != 5 {
|
|
err = ssz.ErrVectorLengthFn("--.TwoDimensionBytesField", size, 5)
|
|
return
|
|
}
|
|
subIndx := hh.Index()
|
|
for _, i := range f.TwoDimensionBytesField {
|
|
if len(i) != 32 {
|
|
err = ssz.ErrBytesLength
|
|
return
|
|
}
|
|
hh.Append(i)
|
|
}
|
|
hh.Merkleize(subIndx)
|
|
}
|
|
|
|
// Field (7) 'TrailingField'
|
|
if size := len(f.TrailingField); size != 56 {
|
|
err = ssz.ErrBytesLengthFn("--.TrailingField", size, 56)
|
|
return
|
|
}
|
|
hh.PutBytes(f.TrailingField)
|
|
|
|
hh.Merkleize(indx)
|
|
return
|
|
}
|
|
|
|
// MarshalSSZ ssz marshals the VariableNestedContainer object
|
|
func (v *VariableNestedContainer) MarshalSSZ() ([]byte, error) {
|
|
return ssz.MarshalSSZ(v)
|
|
}
|
|
|
|
// MarshalSSZTo ssz marshals the VariableNestedContainer object to a target array
|
|
func (v *VariableNestedContainer) MarshalSSZTo(buf []byte) (dst []byte, err error) {
|
|
dst = buf
|
|
offset := int(12)
|
|
|
|
// Field (0) 'Value1'
|
|
dst = ssz.MarshalUint64(dst, v.Value1)
|
|
|
|
// Offset (1) 'FieldListUint64'
|
|
dst = ssz.WriteOffset(dst, offset)
|
|
offset += len(v.FieldListUint64) * 8
|
|
|
|
// Field (1) 'FieldListUint64'
|
|
if size := len(v.FieldListUint64); size > 100 {
|
|
err = ssz.ErrListTooBigFn("--.FieldListUint64", size, 100)
|
|
return
|
|
}
|
|
for ii := 0; ii < len(v.FieldListUint64); ii++ {
|
|
dst = ssz.MarshalUint64(dst, v.FieldListUint64[ii])
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// UnmarshalSSZ ssz unmarshals the VariableNestedContainer object
|
|
func (v *VariableNestedContainer) UnmarshalSSZ(buf []byte) error {
|
|
var err error
|
|
size := uint64(len(buf))
|
|
if size < 12 {
|
|
return ssz.ErrSize
|
|
}
|
|
|
|
tail := buf
|
|
var o1 uint64
|
|
|
|
// Field (0) 'Value1'
|
|
v.Value1 = ssz.UnmarshallUint64(buf[0:8])
|
|
|
|
// Offset (1) 'FieldListUint64'
|
|
if o1 = ssz.ReadOffset(buf[8:12]); o1 > size {
|
|
return ssz.ErrOffset
|
|
}
|
|
|
|
if o1 != 12 {
|
|
return ssz.ErrInvalidVariableOffset
|
|
}
|
|
|
|
// Field (1) 'FieldListUint64'
|
|
{
|
|
buf = tail[o1:]
|
|
num, err := ssz.DivideInt2(len(buf), 8, 100)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
v.FieldListUint64 = ssz.ExtendUint64(v.FieldListUint64, num)
|
|
for ii := 0; ii < num; ii++ {
|
|
v.FieldListUint64[ii] = ssz.UnmarshallUint64(buf[ii*8 : (ii+1)*8])
|
|
}
|
|
}
|
|
return err
|
|
}
|
|
|
|
// SizeSSZ returns the ssz encoded size in bytes for the VariableNestedContainer object
|
|
func (v *VariableNestedContainer) SizeSSZ() (size int) {
|
|
size = 12
|
|
|
|
// Field (1) 'FieldListUint64'
|
|
size += len(v.FieldListUint64) * 8
|
|
|
|
return
|
|
}
|
|
|
|
// HashTreeRoot ssz hashes the VariableNestedContainer object
|
|
func (v *VariableNestedContainer) HashTreeRoot() ([32]byte, error) {
|
|
return ssz.HashWithDefaultHasher(v)
|
|
}
|
|
|
|
// HashTreeRootWith ssz hashes the VariableNestedContainer object with a hasher
|
|
func (v *VariableNestedContainer) HashTreeRootWith(hh *ssz.Hasher) (err error) {
|
|
indx := hh.Index()
|
|
|
|
// Field (0) 'Value1'
|
|
hh.PutUint64(v.Value1)
|
|
|
|
// Field (1) 'FieldListUint64'
|
|
{
|
|
if size := len(v.FieldListUint64); size > 100 {
|
|
err = ssz.ErrListTooBigFn("--.FieldListUint64", size, 100)
|
|
return
|
|
}
|
|
subIndx := hh.Index()
|
|
for _, i := range v.FieldListUint64 {
|
|
hh.AppendUint64(i)
|
|
}
|
|
hh.FillUpTo32()
|
|
|
|
numItems := uint64(len(v.FieldListUint64))
|
|
hh.MerkleizeWithMixin(subIndx, numItems, ssz.CalculateLimit(100, numItems, 8))
|
|
}
|
|
|
|
hh.Merkleize(indx)
|
|
return
|
|
}
|
|
|
|
// MarshalSSZ ssz marshals the VariableTestContainer object
|
|
func (v *VariableTestContainer) MarshalSSZ() ([]byte, error) {
|
|
return ssz.MarshalSSZ(v)
|
|
}
|
|
|
|
// MarshalSSZTo ssz marshals the VariableTestContainer object to a target array
|
|
func (v *VariableTestContainer) MarshalSSZTo(buf []byte) (dst []byte, err error) {
|
|
dst = buf
|
|
offset := int(104)
|
|
|
|
// Field (0) 'LeadingField'
|
|
if size := len(v.LeadingField); size != 32 {
|
|
err = ssz.ErrBytesLengthFn("--.LeadingField", size, 32)
|
|
return
|
|
}
|
|
dst = append(dst, v.LeadingField...)
|
|
|
|
// Offset (1) 'FieldListUint64'
|
|
dst = ssz.WriteOffset(dst, offset)
|
|
offset += len(v.FieldListUint64) * 8
|
|
|
|
// Offset (2) 'FieldListContainer'
|
|
dst = ssz.WriteOffset(dst, offset)
|
|
offset += len(v.FieldListContainer) * 40
|
|
|
|
// Offset (3) 'FieldListBytes32'
|
|
dst = ssz.WriteOffset(dst, offset)
|
|
offset += len(v.FieldListBytes32) * 32
|
|
|
|
// Offset (4) 'Nested'
|
|
dst = ssz.WriteOffset(dst, offset)
|
|
if v.Nested == nil {
|
|
v.Nested = new(VariableNestedContainer)
|
|
}
|
|
offset += v.Nested.SizeSSZ()
|
|
|
|
// Field (5) 'TrailingField'
|
|
if size := len(v.TrailingField); size != 56 {
|
|
err = ssz.ErrBytesLengthFn("--.TrailingField", size, 56)
|
|
return
|
|
}
|
|
dst = append(dst, v.TrailingField...)
|
|
|
|
// Field (1) 'FieldListUint64'
|
|
if size := len(v.FieldListUint64); size > 2048 {
|
|
err = ssz.ErrListTooBigFn("--.FieldListUint64", size, 2048)
|
|
return
|
|
}
|
|
for ii := 0; ii < len(v.FieldListUint64); ii++ {
|
|
dst = ssz.MarshalUint64(dst, v.FieldListUint64[ii])
|
|
}
|
|
|
|
// Field (2) 'FieldListContainer'
|
|
if size := len(v.FieldListContainer); size > 128 {
|
|
err = ssz.ErrListTooBigFn("--.FieldListContainer", size, 128)
|
|
return
|
|
}
|
|
for ii := 0; ii < len(v.FieldListContainer); ii++ {
|
|
if dst, err = v.FieldListContainer[ii].MarshalSSZTo(dst); err != nil {
|
|
return
|
|
}
|
|
}
|
|
|
|
// Field (3) 'FieldListBytes32'
|
|
if size := len(v.FieldListBytes32); size > 100 {
|
|
err = ssz.ErrListTooBigFn("--.FieldListBytes32", size, 100)
|
|
return
|
|
}
|
|
for ii := 0; ii < len(v.FieldListBytes32); ii++ {
|
|
if size := len(v.FieldListBytes32[ii]); size != 32 {
|
|
err = ssz.ErrBytesLengthFn("--.FieldListBytes32[ii]", size, 32)
|
|
return
|
|
}
|
|
dst = append(dst, v.FieldListBytes32[ii]...)
|
|
}
|
|
|
|
// Field (4) 'Nested'
|
|
if dst, err = v.Nested.MarshalSSZTo(dst); err != nil {
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// UnmarshalSSZ ssz unmarshals the VariableTestContainer object
|
|
func (v *VariableTestContainer) UnmarshalSSZ(buf []byte) error {
|
|
var err error
|
|
size := uint64(len(buf))
|
|
if size < 104 {
|
|
return ssz.ErrSize
|
|
}
|
|
|
|
tail := buf
|
|
var o1, o2, o3, o4 uint64
|
|
|
|
// Field (0) 'LeadingField'
|
|
if cap(v.LeadingField) == 0 {
|
|
v.LeadingField = make([]byte, 0, len(buf[0:32]))
|
|
}
|
|
v.LeadingField = append(v.LeadingField, buf[0:32]...)
|
|
|
|
// Offset (1) 'FieldListUint64'
|
|
if o1 = ssz.ReadOffset(buf[32:36]); o1 > size {
|
|
return ssz.ErrOffset
|
|
}
|
|
|
|
if o1 != 104 {
|
|
return ssz.ErrInvalidVariableOffset
|
|
}
|
|
|
|
// Offset (2) 'FieldListContainer'
|
|
if o2 = ssz.ReadOffset(buf[36:40]); o2 > size || o1 > o2 {
|
|
return ssz.ErrOffset
|
|
}
|
|
|
|
// Offset (3) 'FieldListBytes32'
|
|
if o3 = ssz.ReadOffset(buf[40:44]); o3 > size || o2 > o3 {
|
|
return ssz.ErrOffset
|
|
}
|
|
|
|
// Offset (4) 'Nested'
|
|
if o4 = ssz.ReadOffset(buf[44:48]); o4 > size || o3 > o4 {
|
|
return ssz.ErrOffset
|
|
}
|
|
|
|
// Field (5) 'TrailingField'
|
|
if cap(v.TrailingField) == 0 {
|
|
v.TrailingField = make([]byte, 0, len(buf[48:104]))
|
|
}
|
|
v.TrailingField = append(v.TrailingField, buf[48:104]...)
|
|
|
|
// Field (1) 'FieldListUint64'
|
|
{
|
|
buf = tail[o1:o2]
|
|
num, err := ssz.DivideInt2(len(buf), 8, 2048)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
v.FieldListUint64 = ssz.ExtendUint64(v.FieldListUint64, num)
|
|
for ii := 0; ii < num; ii++ {
|
|
v.FieldListUint64[ii] = ssz.UnmarshallUint64(buf[ii*8 : (ii+1)*8])
|
|
}
|
|
}
|
|
|
|
// Field (2) 'FieldListContainer'
|
|
{
|
|
buf = tail[o2:o3]
|
|
num, err := ssz.DivideInt2(len(buf), 40, 128)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
v.FieldListContainer = make([]*FixedNestedContainer, num)
|
|
for ii := 0; ii < num; ii++ {
|
|
if v.FieldListContainer[ii] == nil {
|
|
v.FieldListContainer[ii] = new(FixedNestedContainer)
|
|
}
|
|
if err = v.FieldListContainer[ii].UnmarshalSSZ(buf[ii*40 : (ii+1)*40]); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
|
|
// Field (3) 'FieldListBytes32'
|
|
{
|
|
buf = tail[o3:o4]
|
|
num, err := ssz.DivideInt2(len(buf), 32, 100)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
v.FieldListBytes32 = make([][]byte, num)
|
|
for ii := 0; ii < num; ii++ {
|
|
if cap(v.FieldListBytes32[ii]) == 0 {
|
|
v.FieldListBytes32[ii] = make([]byte, 0, len(buf[ii*32:(ii+1)*32]))
|
|
}
|
|
v.FieldListBytes32[ii] = append(v.FieldListBytes32[ii], buf[ii*32:(ii+1)*32]...)
|
|
}
|
|
}
|
|
|
|
// Field (4) 'Nested'
|
|
{
|
|
buf = tail[o4:]
|
|
if v.Nested == nil {
|
|
v.Nested = new(VariableNestedContainer)
|
|
}
|
|
if err = v.Nested.UnmarshalSSZ(buf); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return err
|
|
}
|
|
|
|
// SizeSSZ returns the ssz encoded size in bytes for the VariableTestContainer object
|
|
func (v *VariableTestContainer) SizeSSZ() (size int) {
|
|
size = 104
|
|
|
|
// Field (1) 'FieldListUint64'
|
|
size += len(v.FieldListUint64) * 8
|
|
|
|
// Field (2) 'FieldListContainer'
|
|
size += len(v.FieldListContainer) * 40
|
|
|
|
// Field (3) 'FieldListBytes32'
|
|
size += len(v.FieldListBytes32) * 32
|
|
|
|
// Field (4) 'Nested'
|
|
if v.Nested == nil {
|
|
v.Nested = new(VariableNestedContainer)
|
|
}
|
|
size += v.Nested.SizeSSZ()
|
|
|
|
return
|
|
}
|
|
|
|
// HashTreeRoot ssz hashes the VariableTestContainer object
|
|
func (v *VariableTestContainer) HashTreeRoot() ([32]byte, error) {
|
|
return ssz.HashWithDefaultHasher(v)
|
|
}
|
|
|
|
// HashTreeRootWith ssz hashes the VariableTestContainer object with a hasher
|
|
func (v *VariableTestContainer) HashTreeRootWith(hh *ssz.Hasher) (err error) {
|
|
indx := hh.Index()
|
|
|
|
// Field (0) 'LeadingField'
|
|
if size := len(v.LeadingField); size != 32 {
|
|
err = ssz.ErrBytesLengthFn("--.LeadingField", size, 32)
|
|
return
|
|
}
|
|
hh.PutBytes(v.LeadingField)
|
|
|
|
// Field (1) 'FieldListUint64'
|
|
{
|
|
if size := len(v.FieldListUint64); size > 2048 {
|
|
err = ssz.ErrListTooBigFn("--.FieldListUint64", size, 2048)
|
|
return
|
|
}
|
|
subIndx := hh.Index()
|
|
for _, i := range v.FieldListUint64 {
|
|
hh.AppendUint64(i)
|
|
}
|
|
hh.FillUpTo32()
|
|
|
|
numItems := uint64(len(v.FieldListUint64))
|
|
hh.MerkleizeWithMixin(subIndx, numItems, ssz.CalculateLimit(2048, numItems, 8))
|
|
}
|
|
|
|
// Field (2) 'FieldListContainer'
|
|
{
|
|
subIndx := hh.Index()
|
|
num := uint64(len(v.FieldListContainer))
|
|
if num > 128 {
|
|
err = ssz.ErrIncorrectListSize
|
|
return
|
|
}
|
|
for _, elem := range v.FieldListContainer {
|
|
if err = elem.HashTreeRootWith(hh); err != nil {
|
|
return
|
|
}
|
|
}
|
|
hh.MerkleizeWithMixin(subIndx, num, 128)
|
|
}
|
|
|
|
// Field (3) 'FieldListBytes32'
|
|
{
|
|
if size := len(v.FieldListBytes32); size > 100 {
|
|
err = ssz.ErrListTooBigFn("--.FieldListBytes32", size, 100)
|
|
return
|
|
}
|
|
subIndx := hh.Index()
|
|
for _, i := range v.FieldListBytes32 {
|
|
if len(i) != 32 {
|
|
err = ssz.ErrBytesLength
|
|
return
|
|
}
|
|
hh.Append(i)
|
|
}
|
|
|
|
numItems := uint64(len(v.FieldListBytes32))
|
|
hh.MerkleizeWithMixin(subIndx, numItems, 100)
|
|
}
|
|
|
|
// Field (4) 'Nested'
|
|
if err = v.Nested.HashTreeRootWith(hh); err != nil {
|
|
return
|
|
}
|
|
|
|
// Field (5) 'TrailingField'
|
|
if size := len(v.TrailingField); size != 56 {
|
|
err = ssz.ErrBytesLengthFn("--.TrailingField", size, 56)
|
|
return
|
|
}
|
|
hh.PutBytes(v.TrailingField)
|
|
|
|
hh.Merkleize(indx)
|
|
return
|
|
}
|