7591 abi encoding optimization

src/Nethermind/Nethermind.Abi/AbiAddress.cs

@@ -2,10 +2,13 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using System.Text.Json;
-
+using DotNetty.Buffers;
 using Nethermind.Core;
 using Nethermind.Core.Extensions;
+using Nethermind.Serialization.Rlp;
 
 namespace Nethermind.Abi
 {
@@ -21,14 +24,22 @@ private AbiAddress() : base(160)
 
         public override byte[] Encode(object? arg, bool packed)
         {
+            NettyAbiStream nettyAbiStream = new NettyAbiStream(PooledByteBufferAllocator.Default.Buffer(1));
             while (true)
             {
                 switch (arg)
                 {
                     case Address input:
                         {
-                            byte[] bytes = input.Bytes;
-                            return packed ? bytes : bytes.PadLeft(UInt256.LengthInBytes);
+                            if (packed)
+                            {
+                                nettyAbiStream.Write(input.Bytes.ToList());
+                            }
+                            else
+                            {
+                                nettyAbiStream.Write(input.Bytes.PadLeft(UInt256.LengthInBytes).ToList());
+                            }
+                            return nettyAbiStream.AsSpan().ToArray();
                         }
                     case string stringInput:
                         {

src/Nethermind/Nethermind.Abi/AbiEncoder.cs

@@ -2,7 +2,9 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 
 using System;
+using DotNetty.Buffers;
 using Nethermind.Core.Extensions;
+using static Microsoft.FSharp.Core.ByRefKinds;
 
 namespace Nethermind.Abi
 {
@@ -21,6 +23,7 @@ public class AbiEncoder : IAbiEncoder
 
         public byte[] Encode(AbiEncodingStyle encodingStyle, AbiSignature signature, params object[] arguments)
         {
+
             bool packed = (encodingStyle & AbiEncodingStyle.Packed) == AbiEncodingStyle.Packed;
             bool includeSig = encodingStyle == AbiEncodingStyle.IncludeSignature;
 

src/Nethermind/Nethermind.Abi/Nethermind.Abi.csproj

@@ -6,10 +6,15 @@
 
   <ItemGroup>
     <ProjectReference Include="..\Nethermind.Core\Nethermind.Core.csproj" />
+    <ProjectReference Include="..\Nethermind.Serialization.Rlp\Nethermind.Serialization.Rlp.csproj" />
   </ItemGroup>
 
   <ItemGroup>
     <PackageReference Include="MathNet.Numerics.FSharp" />
   </ItemGroup>
 
+  <ItemGroup>
+    <PackageReference Include="Nethermind.DotNetty.Buffers" />
+  </ItemGroup>
+
 </Project>

src/Nethermind/Nethermind.Abi/NettyAbiStream.cs

@@ -0,0 +1,125 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using DotNetty.Buffers;
+using DotNetty.Common.Utilities;
+using Nethermind.Serialization.Rlp;
+
+namespace Nethermind.Abi
+{
+    public sealed class NettyAbiStream : IDisposable
+    {
+
+        private readonly IByteBuffer _buffer;
+
+        private readonly int _initialPosition;
+
+        public NettyAbiStream(IByteBuffer buffer)
+        {
+            _buffer = buffer;
+            _initialPosition = buffer.ReaderIndex;
+        }
+
+        public void Write(ReadOnlySpan<byte> bytesToWrite)
+        {
+            _buffer.EnsureWritable(bytesToWrite.Length);
+
+            Span<byte> target =
+                _buffer.Array.AsSpan(_buffer.ArrayOffset + _buffer.WriterIndex, bytesToWrite.Length);
+            bytesToWrite.CopyTo(target);
+            int newWriterIndex = _buffer.WriterIndex + bytesToWrite.Length;
+
+            _buffer.SetWriterIndex(newWriterIndex);
+        }
+
+        public void Write(IReadOnlyList<byte> bytesToWrite)
+        {
+            _buffer.EnsureWritable(bytesToWrite.Count);
+            Span<byte> target =
+                _buffer.Array.AsSpan(_buffer.ArrayOffset + _buffer.WriterIndex, bytesToWrite.Count);
+            for (int i = 0; i < bytesToWrite.Count; ++i)
+            {
+                target[i] = bytesToWrite[i];
+            }
+
+            int newWriterIndex = _buffer.WriterIndex + bytesToWrite.Count;
+            _buffer.SetWriterIndex(newWriterIndex);
+        }
+
+        public void WriteByte(byte byteToWrite)
+        {
+            _buffer.EnsureWritable(1);
+            _buffer.WriteByte(byteToWrite);
+        }
+
+        public void WriteZero(int length)
+        {
+            _buffer.EnsureWritable(length);
+            _buffer.WriteZero(length);
+        }
+
+        public byte ReadByte()
+        {
+            return _buffer.ReadByte();
+        }
+
+        public Span<byte> Read(int length)
+        {
+            Span<byte> span = _buffer.Array.AsSpan(_buffer.ArrayOffset + _buffer.ReaderIndex, length);
+            _buffer.SkipBytes(span.Length);
+            return span;
+        }
+
+        public Span<byte> Peek(int offset, int length)
+        {
+            Span<byte> span = _buffer.Array.AsSpan(_buffer.ArrayOffset + _buffer.ReaderIndex + offset, length);
+            return span;
+        }
+
+        public byte PeekByte()
+        {
+            byte result = _buffer.ReadByte();
+            _buffer.SetReaderIndex(_buffer.ReaderIndex - 1);
+            return result;
+        }
+
+        public byte PeekByte(int offset)
+        {
+            _buffer.MarkReaderIndex();
+            _buffer.SkipBytes(offset);
+            byte result = _buffer.ReadByte();
+            _buffer.ResetReaderIndex();
+            return result;
+        }
+
+        public void SkipBytes(int length)
+        {
+            _buffer.SkipBytes(length);
+        }
+
+        public int Position
+        {
+            get => _buffer.ReaderIndex - _initialPosition;
+            set => _buffer.SetReaderIndex(_initialPosition + value);
+        }
+
+        public int Length => _buffer.ReadableBytes + (_buffer.ReaderIndex - _initialPosition);
+
+        public bool HasBeenRead => _buffer.ReadableBytes <= 0;
+
+        public string Description => "|NettyAibStream|description missing|";
+
+        /// <summary>
+        /// Note: this include already read bytes, not just the remaining one.
+        /// </summary>
+        /// <returns></returns>
+        public Span<byte> AsSpan() => _buffer.AsSpan(_initialPosition);
+
+        public void Dispose()
+        {
+            _buffer.SafeRelease();
+        }
+    }
+}