Feature external signer

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

@@ -0,0 +1,101 @@
+// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using System;
+using System.Threading.Tasks;
+using FluentAssertions;
+using Nethermind.Core;
+using Nethermind.Core.Crypto;
+using Nethermind.Core.Extensions;
+using Nethermind.Core.Test.Builders;
+using Nethermind.JsonRpc;
+using Nethermind.JsonRpc.Client;
+using NSubstitute;
+using NUnit.Framework;
+
+namespace Nethermind.Blockchain.Test.Consensus
+{
+    [TestFixture]
+    public class ClefSignerTests
+    {
+        [Test]
+        public async Task Sign_SigningHash_RequestHasCorrectParameters()
+        {
+            IJsonRpcClient client = Substitute.For<IJsonRpcClient>();
+            client.Post<string[]>("account_list").Returns(Task.FromResult<string[]?>([TestItem.AddressA!.ToString()]));
+            Task<string?> postMethod = client.Post<string>("account_signData", "text/plain", Arg.Any<string>(), Keccak.Zero);
+            var returnValue = (new byte[65]).ToHexString();
+            postMethod.Returns(returnValue);
+            ClefSigner sut = await ClefSigner.Create(client);
+
+            var result = sut.Sign(Keccak.Zero);
+
+            Assert.That(new Signature(returnValue).Bytes, Is.EqualTo(result.Bytes));
+        }
+
+        [Test]
+        public async Task Sign_SigningCliqueHeader_PassingCorrectClefParametersForRequest()
+        {
+            IJsonRpcClient client = Substitute.For<IJsonRpcClient>();
+            client.Post<string[]>("account_list").Returns(Task.FromResult<string[]?>([TestItem.AddressA!.ToString()]));
+            Task<string?> postMethod = client.Post<string>(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>());
+            var returnValue = (new byte[65]).ToHexString();
+            postMethod.Returns(returnValue);
+            BlockHeader blockHeader = Build.A.BlockHeader.TestObject;
+            ClefSigner sut = await ClefSigner.Create(client);
+
+            sut.Sign(blockHeader);
+
+            await client.Received().Post<string>("account_signData", "application/x-clique-header", Arg.Any<string>(), Arg.Any<string>());
+        }
+
+
+        [TestCase(0, 27)]
+        [TestCase(1, 28)]
+        public async Task Sign_RecoveryIdIsSetToCliqueValues_RecoveryIdIsAdjusted(byte recId, byte expected)
+        {
+            IJsonRpcClient client = Substitute.For<IJsonRpcClient>();
+            client.Post<string[]>("account_list").Returns(Task.FromResult<string[]?>([TestItem.AddressA!.ToString()]));
+            Task<string?> postMethod = client.Post<string>("account_signData", "application/x-clique-header", Arg.Any<string>(), Arg.Any<string>());
+            var returnValue = (new byte[65]);
+            returnValue[64] = recId;
+            postMethod.Returns(returnValue.ToHexString());
+            BlockHeader blockHeader = Build.A.BlockHeader.TestObject;
+            ClefSigner sut = await ClefSigner.Create(client);
+
+            var result = sut.Sign(blockHeader);
+
+            Assert.That(result.V, Is.EqualTo(expected));
+        }
+
+        [Test]
+        public async Task Create_SignerAddressSpecified_CorrectAddressIsSet()
+        {
+            IJsonRpcClient client = Substitute.For<IJsonRpcClient>();
+            client.Post<string[]>("account_list").Returns(Task.FromResult<string[]?>([TestItem.AddressA!.ToString(), TestItem.AddressB!.ToString()]));
+
+            ClefSigner sut = await ClefSigner.Create(client, TestItem.AddressB);
+
+            Assert.That(sut.Address, Is.EqualTo(TestItem.AddressB));
+        }
+
+        [Test]
+        public void Create_SignerAddressDoesNotExists_ThrowInvalidOperationException()
+        {
+            IJsonRpcClient client = Substitute.For<IJsonRpcClient>();
+            client.Post<string[]>("account_list").Returns(Task.FromResult<string[]?>([TestItem.AddressA!.ToString(), TestItem.AddressB!.ToString()]));
+
+            Assert.That(async () => await ClefSigner.Create(client, TestItem.AddressC), Throws.InstanceOf<InvalidOperationException>());
+        }
+
+        [Test]
+        public async Task SetSigner_TryingToASigner_ThrowInvalidOperationException()
+        {
+            IJsonRpcClient client = Substitute.For<IJsonRpcClient>();
+            client.Post<string[]>("account_list").Returns(Task.FromResult<string[]?>([TestItem.AddressA!.ToString()]));
+            ClefSigner sut = await ClefSigner.Create(client);
+
+            Assert.That(() => sut.SetSigner(Build.A.PrivateKey.TestObject), Throws.InstanceOf<InvalidOperationException>());
+        }
+    }
+}

src/Nethermind/Nethermind.Blockchain.Test/Nethermind.Blockchain.Test.csproj

@@ -26,6 +26,7 @@
     <ProjectReference Include="..\Nethermind.Consensus.Ethash\Nethermind.Consensus.Ethash.csproj" />
     <ProjectReference Include="..\Nethermind.Core.Test\Nethermind.Core.Test.csproj" />
     <ProjectReference Include="..\Nethermind.Db.Rocks\Nethermind.Db.Rocks.csproj" />
+    <ProjectReference Include="..\Nethermind.ExternalSigner.Plugin\Nethermind.ExternalSigner.Plugin.csproj" />
     <ProjectReference Include="..\Nethermind.JsonRpc.Test\Nethermind.JsonRpc.Test.csproj" />
     <ProjectReference Include="..\Nethermind.Specs.Test\Nethermind.Specs.Test.csproj" />
   </ItemGroup>

src/Nethermind/Nethermind.Clique.Test/CliqueTests.cs

@@ -13,7 +13,9 @@
 using Nethermind.Int256;
 using Nethermind.Logging;
 using Nethermind.Serialization.Rlp;
+using NSubstitute;
 using NUnit.Framework;
+using System.Threading.Tasks;
 using BlockTree = Nethermind.Blockchain.BlockTree;
 
 namespace Nethermind.Clique.Test
@@ -90,6 +92,22 @@ public void Test_no_signer_data_at_epoch_fails(string blockRlp)
             Assert.True(validSeal);
         }
 
+        [TestCase(Block4Rlp)]
+        public async Task SealBlock_SignerCanSignHeader_FullHeaderIsUsedToSign(string blockRlp)
+        {
+            ISigner signer = Substitute.For<ISigner>();
+            signer.CanSignHeader.Returns(true);
+            signer.CanSign.Returns(true);
+            signer.Address.Returns(new Address("0x7ffc57839b00206d1ad20c69a1981b489f772031"));
+            signer.Sign(Arg.Any<BlockHeader>()).Returns(new Signature(new byte[65]));
+            CliqueSealer sut = new CliqueSealer(signer, new CliqueConfig(), _snapshotManager, LimboLogs.Instance);
+            Block block = Rlp.Decode<Block>(new Rlp(Bytes.FromHexString(blockRlp)));
+
+            await sut.SealBlock(block, System.Threading.CancellationToken.None);
+
+            signer.Received().Sign(Arg.Any<BlockHeader>());
+        }
+
         public static Block GetGenesis()
         {
             Hash256 parentHash = Keccak.Zero;

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

@@ -7,8 +7,11 @@
 using System.Threading.Tasks;
 using Nethermind.Core;
 using Nethermind.Core.Crypto;
+using Nethermind.Core.Extensions;
 using Nethermind.Crypto;
+using Nethermind.JsonRpc;
 using Nethermind.Logging;
+using Nethermind.Serialization.Rlp;
 
 [assembly: InternalsVisibleTo("Nethermind.Clique.Test")]
 
@@ -27,7 +30,6 @@ public CliqueSealer(ISigner signer, ICliqueConfig config, ISnapshotManager snaps
             _snapshotManager = snapshotManager ?? throw new ArgumentNullException(nameof(snapshotManager));
             _config = config ?? throw new ArgumentNullException(nameof(config));
             _signer = signer ?? throw new ArgumentNullException(nameof(signer));
-
             if (config.Epoch == 0) config.Epoch = Clique.DefaultEpochLength;
         }
 
@@ -64,7 +66,20 @@ public CliqueSealer(ISigner signer, ICliqueConfig config, ISnapshotManager snaps
 
             // Sign all the things!
             Hash256 headerHash = SnapshotManager.CalculateCliqueHeaderHash(header);
-            Signature signature = _signer.Sign(headerHash);
+            Signature signature;
+            if (_signer.CanSignHeader)
+            {
+                BlockHeader clone = header.Clone();
+                int extraSeal = 65;
+                clone.ExtraData = clone.ExtraData.Slice(0, clone.ExtraData.Length - extraSeal);
+                clone.Hash = headerHash;
+                signature = _signer.Sign(clone);
+            }
+            else
+            {
+                signature = _signer.Sign(headerHash);
+            }
+
             // Copy signature bytes (R and S)
             byte[] signatureBytes = signature.Bytes;
             Array.Copy(signatureBytes, 0, header.ExtraData, header.ExtraData.Length - Clique.ExtraSealLength, signatureBytes.Length);

src/Nethermind/Nethermind.Consensus.Clique/SnapshotManager.cs

@@ -31,6 +31,7 @@ public class SnapshotManager : ISnapshotManager
         private readonly IDb _blocksDb;
         private ulong _lastSignersCount = 0;
         private readonly LruCache<ValueHash256, Snapshot> _snapshotCache = new(Clique.InMemorySnapshots, "clique snapshots");
+        private static readonly HeaderDecoder _headerDecoder = new HeaderDecoder();
 
         public SnapshotManager(ICliqueConfig cliqueConfig, IDb blocksDb, IBlockTree blockTree, IEthereumEcdsa ecdsa, ILogManager logManager)
         {

src/Nethermind/Nethermind.Consensus/IMiningConfig.cs

@@ -52,4 +52,9 @@ public interface IMiningConfig : IConfig
 
     [ConfigItem(HiddenFromDocs = true, DisabledForCli = true, DefaultValue = "null")]
     IBlocksConfig? BlocksConfig { get; }
+    [ConfigItem(
+    Description = "Url for an external signer like clef: https://github.com/ethereum/go-ethereum/blob/master/cmd/clef/tutorial.md",
+    HiddenFromDocs = false,
+    DefaultValue = "null")]
+    string Signer { get; set; }
 }

src/Nethermind/Nethermind.Consensus/ISigner.cs

@@ -5,6 +5,7 @@
 using Nethermind.Core.Crypto;
 using Nethermind.Crypto;
 using Nethermind.TxPool;
+using System;
 
 namespace Nethermind.Consensus
 {
@@ -14,6 +15,8 @@ public interface ISigner : ITxSigner
         PrivateKey? Key { get; }
         Address Address { get; }
         Signature Sign(Hash256 message);
+        Signature Sign(BlockHeader header);
         bool CanSign { get; }
+        bool CanSignHeader { get; }
     }
 }

src/Nethermind/Nethermind.Consensus/MiningConfig.cs

@@ -70,4 +70,6 @@ public IBlocksConfig? BlocksConfig
             return _blocksConfig;
         }
     }
+
+    public string Signer { get; set; }
 }

src/Nethermind/Nethermind.Consensus/Nethermind.Consensus.csproj

@@ -10,6 +10,7 @@
     <ProjectReference Include="..\Nethermind.Core\Nethermind.Core.csproj" />
     <ProjectReference Include="..\Nethermind.Crypto\Nethermind.Crypto.csproj" />
     <ProjectReference Include="..\Nethermind.Evm\Nethermind.Evm.csproj" />
+    <ProjectReference Include="..\Nethermind.JsonRpc.Connectors\Nethermind.JsonRpc.Clients.csproj" />
     <ProjectReference Include="..\Nethermind.TxPool\Nethermind.TxPool.csproj" />
   </ItemGroup>
 

src/Nethermind/Nethermind.Consensus/NullSigner.cs

@@ -22,8 +22,12 @@ public class NullSigner : ISigner, ISignerStore
 
         public PrivateKey? Key { get; } = null;
 
+        public bool CanSignHeader => false;
+
         public void SetSigner(PrivateKey key) { }
 
         public void SetSigner(ProtectedPrivateKey key) { }
+
+        public Signature Sign(BlockHeader header) { return new(new byte[65]); }
     }
 }

src/Nethermind/Nethermind.Consensus/Signer.cs

@@ -21,6 +21,8 @@ public class Signer : ISigner, ISignerStore
 
         public bool CanSign => _key is not null;
 
+        public bool CanSignHeader => false;
+
         public Signer(ulong chainId, PrivateKey? key, ILogManager logManager)
         {
             _chainId = chainId;
@@ -42,6 +44,11 @@ public Signature Sign(Hash256 message)
             return new Signature(rs, v);
         }
 
+        public Signature Sign(BlockHeader header)
+        {
+            return Sign(header.Hash);
+        }
+
         public ValueTask Sign(Transaction tx)
         {
             Hash256 hash = Keccak.Compute(Rlp.Encode(tx, true, true, _chainId).Bytes);