Ssz encoding generator

src/Nethermind/Nethermind.Merkleization/Merkle.BitArray.cs

@@ -8,17 +8,17 @@ namespace Nethermind.Merkleization;
 
 public static partial class Merkle
 {
-    public static void IzeBitvector(out UInt256 root, BitArray value)
+    public static void Ize(out UInt256 root, BitArray value)
     {
         Merkleizer merkleizer = new Merkleizer(0);
-        merkleizer.FeedBitvector(value);
+        merkleizer.Feed(value);
         merkleizer.CalculateRoot(out root);
     }
 
-    public static void IzeBitlist(out UInt256 root, BitArray value, ulong maximumBitlistLength)
+    public static void Ize(out UInt256 root, BitArray value, ulong limit)
     {
         Merkleizer merkleizer = new Merkleizer(0);
-        merkleizer.FeedBitlist(value, maximumBitlistLength);
+        merkleizer.Feed(value, limit);
         merkleizer.CalculateRoot(out root);
     }
 

src/Nethermind/Nethermind.Merkleization/Merkle.Containers.cs

@@ -67,8 +67,6 @@ namespace Nethermind.Merkleization
 
     public static partial class Merkle
     {
-
-
         //public static void Ize(out UInt256 root, BlsPublicKey container)
         //{
         //    Ize(out root, container.Bytes);

src/Nethermind/Nethermind.Merkleization/Merkle.cs

@@ -114,6 +114,12 @@ public static void Ize(out UInt256 root, uint value)
         root = new UInt256(value);
     }
 
+    public static void Ize(out UInt256 root, long value)
+    {
+        var v = value < 0 ? ulong.MaxValue : 0L;
+        root = new UInt256((ulong)value, v, v, v);
+    }
+
     public static void Ize(out UInt256 root, ulong value)
     {
         root = new UInt256(value);

src/Nethermind/Nethermind.Merkleization/Merkleizer.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Numerics;
 using System.Runtime.InteropServices;
 using Nethermind.Core;
 using Nethermind.Core.Collections;
@@ -58,9 +59,122 @@ public void Feed(UInt256 chunk)
         FeedAtLevel(chunk, 0);
     }
 
-    public void Feed(Span<byte> bytes)
+    public void Feed(long value)
     {
-        FeedAtLevel(MemoryMarshal.Cast<byte, UInt256>(bytes)[0], 0);
+        Merkle.Ize(out _chunks[^1], value);
+        Feed(_chunks[^1]);
+    }
+
+    public void Feed(Span<byte> data, int? limit = null)
+    {
+        if (data.Length is 0)
+        {
+            Merkle.Ize(out _chunks[^1], UInt256.Zero);
+        }
+        else
+        {
+            Merkle.Ize(out _chunks[^1], data);
+        }
+
+        if (limit is not null) Merkle.MixIn(ref _chunks[^1], limit.Value);
+    }
+
+    public void Feed(Span<ushort> data, int? limit = null)
+    {
+        if (data.Length is 0)
+        {
+            Merkle.Ize(out _chunks[^1], UInt256.Zero);
+        }
+        else
+        {
+            Merkle.Ize(out _chunks[^1], MemoryMarshal.Cast<ushort, byte>(data));
+        }
+
+        if (limit is not null) Merkle.MixIn(ref _chunks[^1], limit.Value);
+    }
+
+    public void Feed(Span<short> data, int? limit = null)
+    {
+        if (data.Length is 0)
+        {
+            Merkle.Ize(out _chunks[^1], UInt256.Zero);
+        }
+        else
+        {
+            Merkle.Ize(out _chunks[^1], MemoryMarshal.Cast<short, byte>(data));
+        }
+
+        if (limit is not null) Merkle.MixIn(ref _chunks[^1], limit.Value);
+    }
+
+    public void Feed(Span<uint> data, int? limit = null)
+    {
+        if (data.Length is 0)
+        {
+            Merkle.Ize(out _chunks[^1], UInt256.Zero);
+        }
+        else
+        {
+            Merkle.Ize(out _chunks[^1], MemoryMarshal.Cast<uint, byte>(data));
+        }
+
+        if (limit is not null) Merkle.MixIn(ref _chunks[^1], limit.Value);
+    }
+
+    public void Feed(Span<int> data, int? limit = null)
+    {
+        if (data.Length is 0)
+        {
+            Merkle.Ize(out _chunks[^1], UInt256.Zero);
+        }
+        else
+        {
+            Merkle.Ize(out _chunks[^1], MemoryMarshal.Cast<int, byte>(data));
+        }
+
+        if (limit is not null) Merkle.MixIn(ref _chunks[^1], limit.Value);
+    }
+
+    public void Feed(Span<ulong> data, int? limit = null)
+    {
+        if (data.Length is 0)
+        {
+            Merkle.Ize(out _chunks[^1], UInt256.Zero);
+        }
+        else
+        {
+            Merkle.Ize(out _chunks[^1], MemoryMarshal.Cast<ulong, byte>(data));
+        }
+
+        if (limit is not null) Merkle.MixIn(ref _chunks[^1], limit.Value);
+    }
+
+    public void Feed(Span<long> data, int? limit = null)
+    {
+        if (data.Length is 0)
+        {
+            Merkle.Ize(out _chunks[^1], UInt256.Zero);
+        }
+        else
+        {
+            Merkle.Ize(out _chunks[^1], MemoryMarshal.Cast<long, byte>(data));
+        }
+
+        if (limit is not null) Merkle.MixIn(ref _chunks[^1], limit.Value);
+    }
+
+    public void Feed(Span<UInt128> data, int? limit = null)
+    {
+        if (data.Length is 0)
+        {
+            Merkle.Ize(out _chunks[^1], UInt256.Zero);
+        }
+        else
+        {
+            Merkle.Ize(out _chunks[^1], MemoryMarshal.Cast<UInt128, byte>(data));
+        }
+
+        if (limit is not null) Merkle.MixIn(ref _chunks[^1], limit.Value);
     }
 
     public void Feed(bool value)
@@ -74,6 +188,20 @@ public void Feed(uint value)
         Merkle.Ize(out _chunks[^1], value);
         Feed(_chunks[^1]);
     }
+    public void Feed(int value)
+    {
+        Merkle.Ize(out _chunks[^1], value);
+        Feed(_chunks[^1]);
+    }
+    public void Feed(int? value)
+    {
+        if (value is null)
+        {
+            return;
+        }
+        Merkle.Ize(out _chunks[^1], value.Value);
+        Feed(_chunks[^1]);
+    }
 
     public void Feed(ulong value)
     {
@@ -103,27 +231,48 @@ public void FeedBits(byte[]? value, uint limit)
         Feed(_chunks[^1]);
     }
 
-    public void FeedBitvector(BitArray bitArray)
+    public void Feed(BitArray? vector)
     {
+        if (vector is null) return;
         // bitfield_bytes
-        byte[] bytes = new byte[(bitArray.Length + 7) / 8];
-        bitArray.CopyTo(bytes, 0);
+        byte[] bytes = new byte[(vector.Length + 7) / 8];
+        vector.CopyTo(bytes, 0);
 
         Merkle.Ize(out _chunks[^1], bytes);
         Feed(_chunks[^1]);
     }
 
-    public void FeedBitlist(BitArray bitArray, ulong maximumBitlistLength)
+    public void Feed(BitArray? list, ulong maximumBitlistLength)
     {
+        if (list is null) return;
+
         // chunk count
         ulong chunkCount = (maximumBitlistLength + 255) / 256;
 
         // bitfield_bytes
-        byte[] bytes = new byte[(bitArray.Length + 7) / 8];
-        bitArray.CopyTo(bytes, 0);
+        byte[] bytes = new byte[(list.Length + 7) / 8];
+        list.CopyTo(bytes, 0);
 
         Merkle.Ize(out _chunks[^1], bytes, chunkCount);
-        Merkle.MixIn(ref _chunks[^1], bitArray.Length);
+        Merkle.MixIn(ref _chunks[^1], list.Length);
+        Feed(_chunks[^1]);
+    }
+
+    public void Feed(IReadOnlyList<byte[]> value, ulong maxLength)
+    {
+        if (value is null)
+        {
+            return;
+        }
+
+        UInt256[] subRoots = new UInt256[value.Count];
+        for (int i = 0; i < value.Count; i++)
+        {
+            Merkle.Ize(out subRoots[i], value[i]);
+        }
+
+        Merkle.Ize(out _chunks[^1], subRoots, maxLength);
+        Merkle.MixIn(ref _chunks[^1], value.Count);
         Feed(_chunks[^1]);
     }
 
@@ -574,6 +723,20 @@ public void Feed(IReadOnlyList<Bytes32> value, ulong maxLength)
         Feed(_chunks[^1]);
     }
 
+    public void Feed(IReadOnlyList<ulong> value, ulong maxLength)
+    {
+        // TODO: If UInt256 is the correct memory layout
+        UInt256[] subRoots = new UInt256[value.Count];
+        for (int i = 0; i < value.Count; i++)
+        {
+            Merkle.Ize(out subRoots[i], value[i]);
+        }
+
+        Merkle.Ize(out _chunks[^1], subRoots, maxLength);
+        Merkle.MixIn(ref _chunks[^1], value.Count);
+        Feed(_chunks[^1]);
+    }
+
     public void Feed(IReadOnlyList<Root> value)
     {
         UInt256[] input = new UInt256[value.Count];

src/Nethermind/Nethermind.Serialization.Ssz.Test/BitArrayTests.cs

@@ -53,7 +53,7 @@ public void Can_merkleize_bitarray_bitvector(bool[] value, string expectedByteSt
 
             // Act
             var hashTreeRoot = new byte[32];
-            Merkle.IzeBitvector(out UInt256 root, input);
+            Merkle.Ize(out UInt256 root, input);
             root.ToLittleEndian(hashTreeRoot);
 
             // Assert
@@ -97,7 +97,7 @@ public void Can_merkleize_bitarray_bitlist(bool[] value, ulong maximumBitlistLen
 
             // Act
             var hashTreeRoot = new byte[32];
-            Merkle.IzeBitlist(out UInt256 root, input, maximumBitlistLength);
+            Merkle.Ize(out UInt256 root, input, maximumBitlistLength);
             root.ToLittleEndian(hashTreeRoot);
 
             // Assert

src/Nethermind/Nethermind.Serialization.Ssz/Crypto/Ssz.Root.cs

@@ -54,6 +54,8 @@ public static Root DecodeRoot(ReadOnlySpan<byte> span)
         return new Root(span);
     }
 
+
+
     public static Root[] DecodeRoots(ReadOnlySpan<byte> span)
     {
         if (span.Length == 0)

src/Nethermind/Nethermind.Serialization.Ssz/MiscDependencies/Ssz.Bytes32.cs

@@ -12,7 +12,7 @@ public static partial class Ssz
 {
     public const int Bytes32Length = Bytes32.Length;
 
-    public static ReadOnlySpan<byte> DecodeBytes(ReadOnlySpan<byte> span)
+    public static byte[] DecodeBytes(ReadOnlySpan<byte> span)
     {
         return span.ToArray();
     }