Add engine_signalSuperchainV1

src/Nethermind/Nethermind.Core/Extensions/SpanExtensions.cs

@@ -161,6 +161,13 @@ public static ReadOnlySpan<byte> TakeAndMove(this ref ReadOnlySpan<byte> span, i
             return s;
         }
 
+        public static Span<byte> TakeAndMove(this ref Span<byte> span, int length)
+        {
+            Span<byte> s = span[..length];
+            span = span[length..];
+            return s;
+        }
+
         public static bool IsNullOrEmpty<T>(this in Span<T> span) => span.Length == 0;
         public static bool IsNull<T>(this in Span<T> span) => Unsafe.IsNullRef(ref MemoryMarshal.GetReference(span));
         public static bool IsNullOrEmpty<T>(this in ReadOnlySpan<T> span) => span.Length == 0;

src/Nethermind/Nethermind.Core/ProductInfo.cs

@@ -5,6 +5,7 @@
 using System.Linq;
 using System.Reflection;
 using System.Runtime.InteropServices;
+using System.Text;
 
 namespace Nethermind.Core;
 
@@ -22,6 +23,11 @@ static ProductInfo()
             ? DateTimeOffset.FromUnixTimeSeconds(t)
             : DateTimeOffset.MinValue;
         Name = productAttr?.Product ?? "Nethermind";
+
+        ShortName = new byte[8];
+        var nameBytes = Encoding.ASCII.GetBytes(Name);
+        Array.Copy(nameBytes, ShortName, Math.Min(nameBytes.Length, 8));
+
         OS = Platform.GetPlatformName();
         OSArchitecture = RuntimeInformation.OSArchitecture.ToString().ToLowerInvariant();
         Runtime = RuntimeInformation.FrameworkDescription;
@@ -48,6 +54,8 @@ static ProductInfo()
 
     public static string Name { get; }
 
+    public static byte[] ShortName { get; }
+
     public static string OS { get; }
 
     public static string OSArchitecture { get; }

src/Nethermind/Nethermind.Optimism.Test/OptimismProtocolVersionTest.cs

@@ -0,0 +1,153 @@
+// SPDX-FileCopyrightText: 2024 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using System;
+using System.Collections.Generic;
+using FluentAssertions;
+using Nethermind.Core;
+using Nethermind.Core.Extensions;
+using Nethermind.Optimism.ProtocolVersion;
+using NUnit.Framework;
+
+namespace Nethermind.Optimism.Test;
+
+[Parallelizable(ParallelScope.All)]
+public class OptimismProtocolVersionTest
+{
+    private static IEnumerable<(string, OptimismProtocolVersion.V0)> V0ReadWriteCases()
+    {
+        yield return ("0x0000000000000000000000000000000000000000000000000000000000000000", new(new byte[8], 0, 0, 0, 0));
+        yield return ("0x0000000000000000000000000000000000000000000000000000000000000100", new(new byte[8], 0, 0, 0, 1));
+        yield return ("0x0000000000000000000000000000000000000000000000000000010000000000", new(new byte[8], 0, 0, 1, 0));
+        yield return ("0x0000000000000000000000000000000000000400000003000000020000000100", new(new byte[8], 4, 3, 2, 1));
+        yield return ("0x0000000000000000000000000000000000000000000064000000020000000000", new(new byte[8], 0, 100, 2, 0));
+        yield return ("0x000000000000004f502d6d6f6400000000002a00000000000000020000000100", new([(byte)'O', (byte)'P', (byte)'-', (byte)'m', (byte)'o', (byte)'d', 0, 0], 42, 0, 2, 1));
+        yield return ("0x00000000000000626574612e3132330000000100000000000000000000000000", new([(byte)'b', (byte)'e', (byte)'t', (byte)'a', (byte)'.', (byte)'1', (byte)'2', (byte)'3'], 1, 0, 0, 0));
+        yield return ("0x0000000000000061620100000000000000002a00000000000000020000000000", new([(byte)'a', (byte)'b', 1, 0, 0, 0, 0, 0], 42, 0, 2, 0));
+        yield return ("0x0000000000000001020304050607080000002a00000000000000020000000000", new([1, 2, 3, 4, 5, 6, 7, 8], 42, 0, 2, 0));
+    }
+    [TestCaseSource(nameof(V0ReadWriteCases))]
+    public void OptimismProtocolVersionV0_ReadWrite((string HexString, OptimismProtocolVersion.V0 Expected) testCase)
+    {
+        var bytes = Bytes.FromHexString(testCase.HexString);
+        var actual = OptimismProtocolVersion.Read(bytes);
+
+        var bytesWritten = new byte[OptimismProtocolVersion.ByteLength];
+        actual.Write(bytesWritten);
+        var bytesWrittenHex = bytesWritten.ToHexString(withZeroX: true);
+
+        actual.Should().Be(testCase.Expected);
+        testCase.HexString.Should().Be(bytesWrittenHex);
+    }
+
+    private static IEnumerable<(OptimismProtocolVersion.V0, OptimismProtocolVersion.V0, int)> V0CompareCases()
+    {
+        // Pre-release
+        yield return (new(new byte[8], 0, 0, 0, 0), new(new byte[8], 0, 0, 0, 1), 1);
+        yield return (new(new byte[8], 0, 0, 0, 0), new(new byte[8], 0, 0, 0, 2), 1);
+        yield return (new(new byte[8], 0, 0, 0, 0), new(new byte[8], 0, 0, 0, uint.MaxValue), 1);
+        yield return (new(new byte[8], 0, 0, 0, 0), new(new byte[8], 0, 0, 0, 0), 0);
+        yield return (new(new byte[8], 0, 0, 0, 42), new(new byte[8], 0, 0, 0, 42), 0);
+
+        // Patch
+        yield return (new(new byte[8], 0, 0, 1, 0), new(new byte[8], 0, 0, 0, 0), 1);
+        yield return (new(new byte[8], 0, 0, 2, 0), new(new byte[8], 0, 0, 1, 0), 1);
+        yield return (new(new byte[8], 0, 0, uint.MaxValue, 0), new(new byte[8], 0, 0, uint.MaxValue - 1, 0), 1);
+        yield return (new(new byte[8], 0, 0, 0, 0), new(new byte[8], 0, 0, 0, 0), 0);
+        yield return (new(new byte[8], 0, 0, 101, 0), new(new byte[8], 0, 0, 101, 0), 0);
+
+        // Minor
+        yield return (new(new byte[8], 0, 1, 0, 0), new(new byte[8], 0, 0, 0, 0), 1);
+        yield return (new(new byte[8], 0, 2, 0, 0), new(new byte[8], 0, 1, 0, 0), 1);
+        yield return (new(new byte[8], 0, uint.MaxValue, 0, 0), new(new byte[8], 0, uint.MaxValue - 1, 0, 0), 1);
+        yield return (new(new byte[8], 0, 0, 0, 0), new(new byte[8], 0, 0, 0, 0), 0);
+        yield return (new(new byte[8], 0, 200, 0, 0), new(new byte[8], 0, 200, 0, 0), 0);
+
+        // Major
+        yield return (new(new byte[8], 1, 0, 0, 0), new(new byte[8], 0, 0, 0, 0), 1);
+        yield return (new(new byte[8], 2, 0, 0, 0), new(new byte[8], 1, 0, 0, 0), 1);
+        yield return (new(new byte[8], uint.MaxValue, 0, 0, 0), new(new byte[8], uint.MaxValue - 1, 0, 0, 0), 1);
+        yield return (new(new byte[8], 0, 0, 0, 0), new(new byte[8], 0, 0, 0, 0), 0);
+        yield return (new(new byte[8], 300, 0, 0, 0), new(new byte[8], 300, 0, 0, 0), 0);
+
+        // Mixed
+        yield return (new(new byte[8], 1, 2, 3, 4), new(new byte[8], 1, 2, 3, 4), 0);
+        yield return (new(new byte[8], 1, 2, 4, 3), new(new byte[8], 1, 2, 3, 4), 1);
+        yield return (new(new byte[8], 1, 3, 3, 4), new(new byte[8], 1, 2, 3, 4), 1);
+        yield return (new(new byte[8], 2, 2, 3, 4), new(new byte[8], 1, 2, 3, 4), 1);
+        yield return (new(new byte[8], 2, 0, 0, 0), new(new byte[8], 1, 9, 9, 0), 1);
+    }
+    [TestCaseSource(nameof(V0CompareCases))]
+    public void OptimismProtocolVersionV0_Compare((OptimismProtocolVersion.V0 Left, OptimismProtocolVersion.V0 Right, int Expected) testCase)
+    {
+        testCase.Left.CompareTo(testCase.Right).Should().Be(testCase.Expected);
+        testCase.Right.CompareTo(testCase.Left).Should().Be(testCase.Expected * -1);
+    }
+
+    [TestCase("0x0000000000000000000000000000000000000000000000000000000000000000", false)]
+    [TestCase("0x0010000000000000000000000000000000000000000000000000000000000000", true)]
+    [TestCase("0x0001000000000000000000000000000000000000000000000000000000000000", true)]
+    [TestCase("0x0000000000001000000000000000000000000000000000000000000000000000", true)]
+    [TestCase("0x0000000000000100000000000000000000000000000000000000000000000000", true)]
+    public void OptimismProtocolVersionV0_ReservedIsZero(string hexString, bool shouldThrow)
+    {
+        var bytes = Bytes.FromHexString(hexString);
+        Action read = () => OptimismProtocolVersion.Read(bytes);
+
+        if (shouldThrow)
+        {
+            read.Should().Throw<OptimismProtocolVersion.ParseException>();
+        }
+        else
+        {
+            read.Should().NotThrow();
+        }
+    }
+
+    private static IEnumerable<byte[]> InvalidByteArrays()
+    {
+        yield return new byte[8];
+        yield return new byte[16];
+        yield return new byte[24];
+    }
+    [TestCaseSource(nameof(InvalidByteArrays))]
+    public void OptimismProtocolVersion_Throws_Invalid_Length(byte[] bytes)
+    {
+        Action read = () => OptimismProtocolVersion.Read(bytes);
+        read.Should().Throw<OptimismProtocolVersion.ParseException>();
+    }
+
+    [TestCase(1)]
+    [TestCase(5)]
+    [TestCase(byte.MaxValue)]
+    public void OptimismProtocolVersion_Throws_Unknown_Version(byte version)
+    {
+        var bytes = new byte[32];
+        bytes[0] = version;
+
+        Action read = () => OptimismProtocolVersion.Read(bytes);
+        read.Should().Throw<OptimismProtocolVersion.ParseException>();
+    }
+
+
+    private static IEnumerable<(string, OptimismProtocolVersion.V0)> V0FromStringCases()
+    {
+        yield return ("3.1.0", new(new byte[8], 3, 1, 0, 0));
+        yield return ("1.1.1", new(new byte[8], 1, 1, 1, 0));
+        yield return ("1.1.1.16", new(new byte[8], 1, 1, 1, 16));
+        yield return ("1.26.0.4", new(new byte[8], 1, 26, 0, 4));
+    }
+    [TestCaseSource(nameof(V0FromStringCases))]
+    public void OptimismProtocolVersionV0_FromStringVersion((string Version, OptimismProtocolVersion.V0 Expected) testCase)
+    {
+        var actual = new OptimismProtocolVersion.V0(testCase.Version);
+        actual.Should().Be(testCase.Expected);
+    }
+
+    [Test]
+    public void OptimismProtocolVersionV0_FromProductInfoVersion()
+    {
+        Func<OptimismProtocolVersion> fromString = () => new OptimismProtocolVersion.V0(ProductInfo.Version);
+        fromString.Should().NotThrow();
+    }
+}

src/Nethermind/Nethermind.Optimism.Test/Rpc/OptimismEngineRpcModuleTest.cs

@@ -0,0 +1,129 @@
+// SPDX-FileCopyrightText: 2024 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using FluentAssertions;
+using FluentAssertions.Json;
+using Nethermind.JsonRpc;
+using Nethermind.JsonRpc.Test;
+using Nethermind.Merge.Plugin;
+using Nethermind.Optimism.ProtocolVersion;
+using Nethermind.Optimism.Rpc;
+using Nethermind.Serialization.Json;
+using Newtonsoft.Json.Linq;
+using NSubstitute;
+using NUnit.Framework;
+
+namespace Nethermind.Optimism.Test.Rpc;
+
+[Parallelizable(ParallelScope.All)]
+public class OptimismEngineRpcModuleTest
+{
+    private static IEnumerable<(OptimismProtocolVersion, OptimismSuperchainSignal, bool behindRecommended, bool behindRequired)> SignalSuperchainV1Cases()
+    {
+        yield return (
+            new OptimismProtocolVersion.V0(new byte[8], 3, 0, 0, 0),
+            new OptimismSuperchainSignal(
+                Recommended: new OptimismProtocolVersion.V0(new byte[8], 2, 0, 0, 0),
+                Required: new OptimismProtocolVersion.V0(new byte[8], 1, 0, 0, 0)),
+            behindRecommended: false,
+            behindRequired: false
+        );
+
+        yield return (
+            new OptimismProtocolVersion.V0(new byte[8], 2, 0, 0, 0),
+            new OptimismSuperchainSignal(
+                Recommended: new OptimismProtocolVersion.V0(new byte[8], 2, 0, 0, 0),
+                Required: new OptimismProtocolVersion.V0(new byte[8], 1, 0, 0, 0)),
+            behindRecommended: false,
+            behindRequired: false
+        );
+
+        yield return (
+            new OptimismProtocolVersion.V0(new byte[8], 2, 0, 0, 0),
+            new OptimismSuperchainSignal(
+                Recommended: new OptimismProtocolVersion.V0(new byte[8], 3, 0, 0, 0),
+                Required: new OptimismProtocolVersion.V0(new byte[8], 1, 0, 0, 0)),
+            behindRecommended: true,
+            behindRequired: false
+        );
+
+        yield return (
+            new OptimismProtocolVersion.V0(new byte[8], 1, 0, 0, 0),
+            new OptimismSuperchainSignal(
+                Recommended: new OptimismProtocolVersion.V0(new byte[8], 2, 0, 0, 0),
+                Required: new OptimismProtocolVersion.V0(new byte[8], 1, 0, 0, 0)),
+            behindRecommended: true,
+            behindRequired: false
+        );
+
+        yield return (
+            new OptimismProtocolVersion.V0(new byte[8], 1, 0, 0, 0),
+            new OptimismSuperchainSignal(
+                Recommended: new OptimismProtocolVersion.V0(new byte[8], 3, 0, 0, 0),
+                Required: new OptimismProtocolVersion.V0(new byte[8], 2, 0, 0, 0)),
+            behindRecommended: true,
+            behindRequired: true
+        );
+    }
+
+    [TestCaseSource(nameof(SignalSuperchainV1Cases))]
+    public async Task SignalSuperchainV1_ComparesRequiredAndRecommendedVersion((OptimismProtocolVersion current, OptimismSuperchainSignal signal, bool behindRecommended, bool behindRequired) testCase)
+    {
+        var current = testCase.current;
+        var signal = testCase.signal;
+
+        var handler = Substitute.For<IOptimismSignalSuperchainV1Handler>();
+        handler.CurrentVersion.Returns(current);
+        IOptimismEngineRpcModule rpcModule = new OptimismEngineRpcModule(Substitute.For<IEngineRpcModule>(), handler);
+
+        _ = await rpcModule.engine_signalSuperchainV1(signal);
+
+        await handler.Received(testCase.behindRecommended ? 1 : 0).OnBehindRecommended(testCase.signal.Recommended);
+
+        await handler.Received(testCase.behindRequired ? 1 : 0).OnBehindRequired(testCase.signal.Required);
+    }
+
+    [Test]
+    public async Task SignalSuperchainV1_ReturnsCurrentVersion()
+    {
+        var current = new OptimismProtocolVersion.V0(new byte[8], 3, 2, 1, 0);
+        var signal = new OptimismSuperchainSignal(
+            Recommended: new OptimismProtocolVersion.V0(new byte[8], 2, 0, 0, 0),
+            Required: new OptimismProtocolVersion.V0(new byte[8], 1, 0, 0, 0));
+
+        var handler = Substitute.For<IOptimismSignalSuperchainV1Handler>();
+        handler.CurrentVersion.Returns(current);
+        IOptimismEngineRpcModule rpcModule = new OptimismEngineRpcModule(Substitute.For<IEngineRpcModule>(), handler);
+
+        ResultWrapper<OptimismSignalSuperchainV1Result> result = await rpcModule.engine_signalSuperchainV1(signal);
+
+        result.Data.Should().Be(new OptimismSignalSuperchainV1Result(current));
+    }
+
+    private static IEnumerable<(string, string, OptimismProtocolVersion)> SignalSuperchainV1JsonCases()
+    {
+        yield return (
+            """{"recommended":"0x0000000000000000000000000000000000000200000000000000000000000000","required":"0x0000000000000000000000000000000000000100000000000000000000000000"}""",
+            """{"protocolVersion":"0x0000000000000000000000000000000000000300000002000000010000000000"}""",
+            new OptimismProtocolVersion.V0(new byte[8], 3, 2, 1, 0));
+
+        yield return (
+            """{"recommended":"0x0000000000000000000000000000000000000400000000000000000000000000","required":"0x0000000000000000000000000000000000000300000000000000000000000000"}""",
+            """{"protocolVersion":"0x00000000000000000000000000000000000002000000090000000a0000000000"}""",
+            new OptimismProtocolVersion.V0(new byte[8], 2, 9, 10, 0));
+    }
+    [TestCaseSource(nameof(SignalSuperchainV1JsonCases))]
+    public async Task SignalSuperchainV1_JsonRpc((string Signal, string Expected, OptimismProtocolVersion Current) testCase)
+    {
+        var handler = Substitute.For<IOptimismSignalSuperchainV1Handler>();
+        handler.CurrentVersion.Returns(testCase.Current);
+        IOptimismEngineRpcModule rpcModule = new OptimismEngineRpcModule(Substitute.For<IEngineRpcModule>(), handler);
+
+        var signal = new EthereumJsonSerializer().Deserialize<OptimismSuperchainSignal>(testCase.Signal);
+        var response = await RpcTest.TestSerializedRequest(rpcModule, "engine_signalSuperchainV1", signal);
+
+        JToken.Parse(response).Should().BeEquivalentTo($$"""{"jsonrpc":"2.0","result":{{testCase.Expected}},"id":67}""");
+    }
+}

src/Nethermind/Nethermind.Optimism/OptimismPlugin.cs

@@ -31,6 +31,7 @@
 using Nethermind.Serialization.Rlp;
 using Nethermind.Optimism.Rpc;
 using Nethermind.Synchronization;
+using Nethermind.Optimism.ProtocolVersion;
 
 namespace Nethermind.Optimism;
 
@@ -272,7 +273,10 @@ public async Task InitRpcModules()
                     : new NoSyncGcRegionStrategy(_api.SyncModeSelector, _mergeConfig), _api.LogManager),
             _api.LogManager);
 
-        IOptimismEngineRpcModule opEngine = new OptimismEngineRpcModule(engineRpcModule);
+        OptimismProtocolVersion currentVersion = new OptimismProtocolVersion.V0(ProductInfo.ShortName, ProductInfo.Version);
+        IOptimismSignalSuperchainV1Handler signalHandler = new LoggingOptimismSignalSuperchainV1Handler(currentVersion, _api.LogManager);
+
+        IOptimismEngineRpcModule opEngine = new OptimismEngineRpcModule(engineRpcModule, signalHandler);
 
         _api.RpcModuleProvider.RegisterSingle(opEngine);