Back signature by Vector512 rather than byte[]

src/Nethermind/Ethereum.Basic.Test/TransactionTests.cs

@@ -50,7 +50,7 @@ public void Test(TransactionTest test)
 
             Transaction decodedSigned = Rlp.Decode<Transaction>(test.Signed);
             ethereumEcdsa.Sign(test.PrivateKey, decodedUnsigned, false);
-            Assert.That(decodedUnsigned.Signature.R, Is.EqualTo(decodedSigned.Signature.R), "R");
+            Assert.That(decodedUnsigned.Signature.R.SequenceEqual(decodedSigned.Signature.R), "R");
             BigInteger expectedS = decodedSigned.Signature.S.ToUnsignedBigInteger();
             BigInteger actualS = decodedUnsigned.Signature.S.ToUnsignedBigInteger();
             BigInteger otherS = EthereumEcdsa.LowSTransform - actualS;

src/Nethermind/Nethermind.Blockchain.Test/Consensus/ClefSignerTests.cs

@@ -29,7 +29,7 @@ public async Task Sign_SigningHash_RequestHasCorrectParameters()
 
             var result = sut.Sign(Keccak.Zero);
 
-            Assert.That(new Signature(returnValue).Bytes, Is.EqualTo(result.Bytes));
+            Assert.That(new Signature(returnValue).Bytes.SequenceEqual(result.Bytes));
         }
 
         [Test]

src/Nethermind/Nethermind.Blockchain.Test/Consensus/NullSignerTests.cs

@@ -27,7 +27,7 @@ public async Task Test_signing()
         {
             NullSigner signer = NullSigner.Instance;
             await signer.Sign((Transaction)null!);
-            signer.Sign((Hash256)null!).Bytes.Should().HaveCount(64);
+            signer.Sign((Hash256)null!).Bytes.Length.Should().Be(64);
         }
     }
 }

src/Nethermind/Nethermind.Blockchain.Test/Consensus/SignerTests.cs

@@ -64,7 +64,7 @@ public async Task Test_signing()
         {
             Signer signer = new(1, TestItem.PrivateKeyA, LimboLogs.Instance);
             await signer.Sign(Build.A.Transaction.TestObject);
-            signer.Sign(Keccak.Zero).Bytes.Should().HaveCount(64);
+            signer.Sign(Keccak.Zero).Bytes.Length.Should().Be(64);
         }
     }
 }

src/Nethermind/Nethermind.Consensus.Clique/CliqueSealer.cs

@@ -77,8 +77,8 @@ public CliqueSealer(ISigner signer, ICliqueConfig config, ISnapshotManager snaps
             }
 
             // Copy signature bytes (R and S)
-            byte[] signatureBytes = signature.Bytes;
-            Array.Copy(signatureBytes, 0, header.ExtraData, header.ExtraData.Length - Clique.ExtraSealLength, signatureBytes.Length);
+            ReadOnlySpan<byte> signatureBytes = signature.Bytes;
+            signatureBytes.CopyTo(header.ExtraData.AsSpan(header.ExtraData.Length - Clique.ExtraSealLength));
             // Copy signature's recovery id (V)
             byte recoveryId = signature.RecoveryId;
             header.ExtraData[^1] = recoveryId;

src/Nethermind/Nethermind.Core.Test/Crypto/SignatureTests.cs

@@ -41,7 +41,7 @@ public void can_recover_from_message()
         var signatureObject = new Signature(signatureSlice, recoveryId);
         var keccak = Keccak.Compute(Bytes.Concat(messageType, data));
         Span<byte> publicKey = stackalloc byte[65];
-        bool result = SpanSecP256k1.RecoverKeyFromCompact(publicKey, keccak.Bytes, signatureObject.Bytes, signatureObject.RecoveryId, false);
+        bool result = SpanSecP256k1.RecoverKeyFromCompact(publicKey, keccak.Bytes, signatureObject.Bytes.ToArray(), signatureObject.RecoveryId, false);
         result.Should().BeTrue();
     }
 }

src/Nethermind/Nethermind.Core/Crypto/Signature.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
 using Nethermind.Core.Attributes;
 using Nethermind.Core.Extensions;
 using Nethermind.Int256;
@@ -12,38 +13,41 @@ namespace Nethermind.Core.Crypto
     public class Signature : IEquatable<Signature>
     {
         public const int VOffset = 27;
+        private Vector512<byte> _signature;
 
         public Signature(ReadOnlySpan<byte> bytes, int recoveryId)
         {
             ArgumentOutOfRangeException.ThrowIfNotEqual(bytes.Length, 64);
 
-            bytes.CopyTo(Bytes.AsSpan());
+            bytes.CopyTo(Bytes);
             V = (ulong)recoveryId + VOffset;
         }
 
         public Signature(ReadOnlySpan<byte> bytes)
         {
             ArgumentOutOfRangeException.ThrowIfNotEqual(bytes.Length, 65);
 
-            bytes[..64].CopyTo(Bytes.AsSpan());
+            bytes[..64].CopyTo(Bytes);
             V = bytes[64];
         }
 
         public Signature(ReadOnlySpan<byte> r, ReadOnlySpan<byte> s, ulong v)
         {
             ArgumentOutOfRangeException.ThrowIfLessThan(v, (ulong)VOffset);
 
-            r.CopyTo(Bytes.AsSpan(32 - r.Length, r.Length));
-            s.CopyTo(Bytes.AsSpan(64 - s.Length, s.Length));
+            Span<byte> span = Bytes;
+            r.CopyTo(span.Slice(32 - r.Length, r.Length));
+            s.CopyTo(span.Slice(64 - s.Length, s.Length));
             V = v;
         }
 
         public Signature(in UInt256 r, in UInt256 s, ulong v)
         {
             ArgumentOutOfRangeException.ThrowIfLessThan(v, (ulong)VOffset);
 
-            r.ToBigEndian(Bytes.AsSpan(0, 32));
-            s.ToBigEndian(Bytes.AsSpan(32, 32));
+            Span<byte> span = Bytes;
+            r.ToBigEndian(span.Slice(0, 32));
+            s.ToBigEndian(span.Slice(32, 32));
 
             V = v;
         }
@@ -52,26 +56,25 @@ public Signature(string hexString)
             : this(Core.Extensions.Bytes.FromHexString(hexString))
         {
         }
-
-        public byte[] Bytes { get; } = new byte[64];
+        public Span<byte> Bytes => MemoryMarshal.AsBytes(MemoryMarshal.CreateSpan(ref _signature, 1));
         public ulong V { get; set; }
 
         public ulong? ChainId => V < 35 ? null : (ulong?)(V + (V % 2) - 36) / 2;
 
         public byte RecoveryId => V <= VOffset + 1 ? (byte)(V - VOffset) : (byte)(1 - V % 2);
 
-        public byte[] R => Bytes.Slice(0, 32);
-        public Span<byte> RAsSpan => Bytes.AsSpan(0, 32);
-        public byte[] S => Bytes.Slice(32, 32);
-        public Span<byte> SAsSpan => Bytes.AsSpan(32, 32);
+        public ReadOnlySpan<byte> R => Bytes.Slice(0, 32);
+        public ReadOnlySpan<byte> RAsSpan => Bytes.Slice(0, 32);
+        public ReadOnlySpan<byte> S => Bytes.Slice(32, 32);
+        public ReadOnlySpan<byte> SAsSpan => Bytes.Slice(32, 32);
 
         [Todo("Change signature to store 65 bytes and just slice it for normal Bytes.")]
         public byte[] BytesWithRecovery
         {
             get
             {
                 var result = new byte[65];
-                Array.Copy(Bytes, result, 64);
+                Bytes.CopyTo(result);
                 result[64] = RecoveryId;
                 return result;
             }
@@ -87,7 +90,7 @@ public bool Equals(Signature? other)
         {
             if (other is null) return false;
             if (ReferenceEquals(this, other)) return true;
-            return Core.Extensions.Bytes.AreEqual(Bytes, other.Bytes) && V == other.V;
+            return _signature == other._signature && V == other.V;
         }
 
         public override bool Equals(object? obj)

src/Nethermind/Nethermind.Core/Extensions/Bytes.cs

@@ -346,6 +346,14 @@ public static byte[] Concat(byte[] bytes, byte suffix)
             return result;
         }
 
+        public static byte[] Concat(ReadOnlySpan<byte> bytes, byte suffix)
+        {
+            byte[] result = new byte[bytes.Length + 1];
+            result[^1] = suffix;
+            bytes.CopyTo(result);
+            return result;
+        }
+
         public static byte[] Reverse(byte[] bytes)
         {
             byte[] result = new byte[bytes.Length];

src/Nethermind/Nethermind.Core/Transaction.cs

@@ -231,7 +231,7 @@ public string ToString(string indent)
             builder.AppendLine($"{indent}Nonce:     {Nonce}");
             builder.AppendLine($"{indent}Value:     {Value}");
             builder.AppendLine($"{indent}Data:      {(Data.AsArray() ?? []).ToHexString()}");
-            builder.AppendLine($"{indent}Signature: {(Signature?.Bytes ?? []).ToHexString()}");
+            builder.AppendLine($"{indent}Signature: {Signature?.Bytes.ToHexString()}");
             builder.AppendLine($"{indent}V:         {Signature?.V}");
             builder.AppendLine($"{indent}ChainId:   {Signature?.ChainId}");
             builder.AppendLine($"{indent}Timestamp: {Timestamp}");

src/Nethermind/Nethermind.Facade/Eth/RpcTransaction/LegacyTransactionForRpc.cs

@@ -73,9 +73,19 @@ public LegacyTransactionForRpc(Transaction transaction, int? txIndex = null, Has
         GasPrice = transaction.GasPrice;
         ChainId = transaction.ChainId;
 
-        R = new UInt256(transaction.Signature?.R ?? [], true);
-        S = new UInt256(transaction.Signature?.S ?? [], true);
-        V = transaction.Signature?.V ?? 0;
+        Signature? signature = transaction.Signature;
+        if (signature is null)
+        {
+            R = UInt256.Zero;
+            S = UInt256.Zero;
+            V = 0;
+        }
+        else
+        {
+            R = new UInt256(signature.R, true);
+            S = new UInt256(signature.S, true);
+            V = signature.V;
+        }
     }
 
     public override Transaction ToTransaction()

src/Nethermind/Nethermind.JsonRpc.Test/Modules/Eth/EthRpcSimulateTestsBase.cs

@@ -127,7 +127,7 @@ protected static byte[] GenerateTransactionDataForEcRecover(Hash256 keccak, Sign
     {
         AbiDefinition call = new AbiDefinitionParser().Parse(GetEcRecoverContractJsonAbi(name));
         AbiEncodingInfo functionInfo = call.GetFunction(name).GetCallInfo();
-        return AbiEncoder.Instance.Encode(functionInfo.EncodingStyle, functionInfo.Signature, keccak, signature.V, signature.R, signature.S);
+        return AbiEncoder.Instance.Encode(functionInfo.EncodingStyle, functionInfo.Signature, keccak, signature.V, signature.R.ToArray(), signature.S.ToArray());
     }
 
     private static Address? ParseEcRecoverAddress(byte[] data, string name = "recover")

src/Nethermind/Nethermind.JsonRpc/Modules/Eth/EthRpcModule.cs

@@ -285,7 +285,7 @@ public ResultWrapper<byte[]> eth_sign(Address addressData, byte[] message)
         }
 
         if (_logger.IsTrace) _logger.Trace($"eth_sign request {addressData}, {message}, result: {sig}");
-        return ResultWrapper<byte[]>.Success(sig.Bytes);
+        return ResultWrapper<byte[]>.Success(sig.Bytes.ToArray());
     }
 
     public virtual Task<ResultWrapper<Hash256>> eth_sendTransaction(TransactionForRpc rpcTx)

src/Nethermind/Nethermind.JsonRpc/Modules/Parity/ParityTransaction.cs

@@ -60,8 +60,8 @@ public ParityTransaction(Transaction transaction, byte[] raw, PublicKey publicKe
             Input = transaction.Data.AsArray();
             PublicKey = publicKey;
             ChainId = transaction.Signature.ChainId;
-            R = transaction.Signature.R;
-            S = transaction.Signature.S;
+            R = transaction.Signature.R.ToArray();
+            S = transaction.Signature.S.ToArray();
             V = (UInt256)transaction.Signature.V;
             StandardV = transaction.Signature.RecoveryId;
             // TKS: it does not seem to work with CREATE2

src/Nethermind/Nethermind.JsonRpc/Modules/Personal/PersonalRpcModule.cs

@@ -96,7 +96,7 @@ public ResultWrapper<byte[]> personal_sign(byte[] message, Address address, stri
             }
 
             message = ToEthSignedMessage(message);
-            return ResultWrapper<byte[]>.Success(_wallet.Sign(Keccak.Compute(message), address).Bytes);
+            return ResultWrapper<byte[]>.Success(_wallet.Sign(Keccak.Compute(message), address).Bytes.ToArray());
         }
     }
 }

src/Nethermind/Nethermind.Network.Discovery/Serializers/DiscoveryMsgSerializerBase.cs

@@ -48,7 +48,7 @@ protected void Serialize(byte type, Span<byte> data, IByteBuffer byteBuffer)
 
         Signature signature = _ecdsa.Sign(_privateKey, toSign);
         byteBuffer.SetWriterIndex(startWriteIndex + 32);
-        byteBuffer.WriteBytes(signature.Bytes, 0, 64);
+        byteBuffer.WriteBytes(signature.Bytes);
         byteBuffer.WriteByte(signature.RecoveryId);
 
         byteBuffer.SetReaderIndex(startReadIndex + 32);
@@ -76,7 +76,7 @@ protected void AddSignatureAndMdc(IByteBuffer byteBuffer, int dataLength)
 
         Signature signature = _ecdsa.Sign(_privateKey, toSign);
         byteBuffer.SetWriterIndex(startWriteIndex + 32);
-        byteBuffer.WriteBytes(signature.Bytes, 0, 64);
+        byteBuffer.WriteBytes(signature.Bytes);
         byteBuffer.WriteByte(signature.RecoveryId);
 
         byteBuffer.SetWriterIndex(startWriteIndex + length);

src/Nethermind/Nethermind.Serialization.Rlp/Eip7702/AuthorizationTupleDecoder.cs

@@ -106,8 +106,8 @@ public void EncodeWithoutSignature(RlpStream stream, UInt256 chainId, Address co
     private static int GetContentLength(AuthorizationTuple tuple) =>
         GetContentLengthWithoutSig(tuple.ChainId, tuple.CodeAddress, tuple.Nonce)
         + Rlp.LengthOf(tuple.AuthoritySignature.V - Signature.VOffset)
-        + Rlp.LengthOf(new UInt256(tuple.AuthoritySignature.R.AsSpan(), true))
-        + Rlp.LengthOf(new UInt256(tuple.AuthoritySignature.S.AsSpan(), true));
+        + Rlp.LengthOf(new UInt256(tuple.AuthoritySignature.R, true))
+        + Rlp.LengthOf(new UInt256(tuple.AuthoritySignature.S, true));
 
     private static int GetContentLengthWithoutSig(UInt256 chainId, Address codeAddress, ulong nonce) =>
         Rlp.LengthOf(chainId)