Merkle Node Keccak

[emlautarom1]

Compute the Keccak or RLP of Merkle Nodes (Branches, Leaves and Extensions)

[emlautarom1]

There are multiple "magic numbers" in the class. We should extract them into constants and document the reason for their existence (spec, optimization, etc.)

[emlautarom1]

Optimization opportunity by reusing results on known inputs.

[Scooletz]

Would be super useful if you could provide a link to a branch in NethermindEth maybe where you calculate these. Once they are merged, it will be fine but for now, keeping any kind of link would make the life much easier.

[emlautarom1]

I had the tests locally, but I'll create a branch with the actual tests.

[emlautarom1]

I've created a branch with the same tests: https://github.com/NethermindEth/nethermind/tree/feature/paprika_merkle_tests.

[Scooletz]

Could you commit this link to the repository? Otherwise it will get lost. Just add it to the tests.

[emlautarom1]

I actually did that but I forgot to push the changes. Whoops!

[emlautarom1]

Removed all allocations with a little help of scoped and manually inlining methods.

[emlautarom1]

I also tried a different approach that uses a fixed size array instead of a Keccak:

public ref struct KeccakOrRlp
{
    public enum Type : byte
    {
        Keccak = 0,
        Rlp = 1,
    }

    private unsafe ref struct Buffer
    {
        private const int Size = 32;

#pragma warning disable CS0649
        // Compiler cannot figure out that the fields is being used
        private fixed byte _data[Size];
#pragma warning restore CS0649

        public Span<byte> AsSpan()
        {
            fixed (byte* p = _data)
            {
                return new Span<byte>(p, Size);
            }
        }
    }

    public Type DataType { get; }
    private Buffer _buffer;

    public Span<byte> AsSpan() => _buffer.AsSpan();

    private KeccakOrRlp(Type dataType, Buffer buffer)
    {
        DataType = dataType;
        _buffer = buffer;
    }

    public static KeccakOrRlp FromSpan(scoped Span<byte> data)
    {
        var buffer = new Buffer();
        var output = buffer.AsSpan();

        if (data.Length < 32)
        {
            output[0] = (byte)data.Length;
            data.CopyTo(output[1..]);
            return new KeccakOrRlp(Type.Rlp, buffer);
        }
        else
        {
            KeccakHash.ComputeHash(data, output);
            return new KeccakOrRlp(Type.Keccak, buffer);
        }
    }
}

On benchmarks, this approach is as performant as the Keccak implementation, while in my opinion being a bit clearer since we're not using a Keccak as a backing field (which, when we store an Rlp is not even a Keccak).

I don't see any extra copies on IL, but I'm not fully sure about that.

[Scooletz]

This should work as you describe.

[emlautarom1]

Should we use this approach then? Or would you rather stick with the Keccak approach?

[Scooletz]

One remark and good to merge.

[github-actions]

Package	Line Rate	Branch Rate	Health
Paprika	86%	75%	✔
Summary	86% (1871 / 2163)	75% (463 / 614)	✔

Minimum allowed line rate is 75%

Change has been made as requested

[Scooletz]

Good to go!