Refactor sign tx

src/Nethermind/Nethermind.Xdc.Test/Helpers/XdcTestBlockchain.cs

@@ -176,9 +176,9 @@ protected override ContainerBuilder ConfigureContainer(ContainerBuilder builder,
                     ctx.Resolve<ITxPoolConfig>(),
                     ctx.Resolve<ITxValidator>(),
                     ctx.Resolve<ILogManager>(),
-                    new XdcTransactionComparerProvider(SpecProvider, BlockTree).GetDefaultComparer(),
+                    new XdcTransactionComparerProvider(ctx.Resolve<ISpecProvider>(), ctx.Resolve<IBlockTree>()).GetDefaultComparer(),
                     ctx.Resolve<ITxGossipPolicy>(),
-                    new SignTransactionFilter(SnapshotManager, BlockTree, SpecProvider),
+                    new SignTransactionFilter(ctx.Resolve<ISnapshotManager>(), ctx.Resolve<IBlockTree>(), ctx.Resolve<ISpecProvider>()),
                     ctx.Resolve<ITxValidator>()
                 );
 
@@ -453,15 +453,15 @@ public override async Task<Block> AddBlock(params Transaction[] transactions)
 
     public override async Task<Block> AddBlockFromParent(BlockHeader parent, params Transaction[] transactions)
     {
-        Block b = await base.AddBlockFromParent(parent, transactions);
+        Block b = await _fromContainer.TestBlockchainUtil.AddBlock(parent, TestBlockchainUtil.AddBlockFlags.DoNotWaitForHead | TestBlockchainUtil.AddBlockFlags.MayHaveExtraTx, CreateCancellationSource().Token, transactions);
         CreateAndCommitQC((XdcBlockHeader)b.Header);
 
         return b;
     }
 
     public async Task<Block> AddBlockWithoutCommitQc(params Transaction[] txs)
     {
-        await base.AddBlock(txs);
+        await base.AddBlockMayHaveExtraTx(txs);
         return BlockTree.Head!;
     }
 

src/Nethermind/Nethermind.Xdc/SignTransactionManager.cs

@@ -2,21 +2,37 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 
 
+using Microsoft.Extensions.Logging;
+using Nethermind.Blockchain;
 using Nethermind.Consensus;
 using Nethermind.Core;
+using Nethermind.Core.Caching;
 using Nethermind.Core.Crypto;
 using Nethermind.Core.Extensions;
+using Nethermind.Core.Specs;
 using Nethermind.Crypto;
 using Nethermind.Int256;
+using Nethermind.Logging;
 using Nethermind.TxPool;
 using Nethermind.Xdc.Spec;
-using Nethermind.Logging;
+using Nethermind.Xdc.Types;
+using System;
 using System.Threading.Tasks;
 
 namespace Nethermind.Xdc;
 
-internal class SignTransactionManager(ISigner signer, ITxPool txPool, ILogger logger) : ISignTransactionManager
+internal class SignTransactionManager(
+    ISigner signer,
+    ITxPool txPool,
+    IBlockTree blockTree,
+    ISnapshotManager snapshotManager,
+    ISpecProvider specProvider,
+    ILogManager logManager) : ISignTransactionManager, IStartable, IDisposable
 {
+    private readonly AssociativeKeyCache<ValueHash256> _alreadySigned = new(128);
+    private Logging.ILogger _logger = logManager.GetClassLogger<SignTransactionManager>();
+    public void Start() => blockTree.BlockAddedToMain += OnBlockAddedToMain;
+
     public async Task SubmitTransactionSign(XdcBlockHeader header, IXdcReleaseSpec spec)
     {
         UInt256 nonce = txPool.GetLatestPendingNonce(signer.Address);
@@ -29,10 +45,45 @@
         AcceptTxResult added = txPool.SubmitTx(transaction, TxHandlingOptions.PersistentBroadcast);
         if (!added)
         {
-            logger.Warn($"Failed to add signed transaction to the pool: {added} {header.ToString(BlockHeader.Format.FullHashAndNumber)}");
+            _logger.Warn($"Failed to add signed transaction to the pool: {added} {header.ToString(BlockHeader.Format.FullHashAndNumber)}");
+        }
+    }
+
+    private void OnBlockAddedToMain(object? sender, BlockReplacementEventArgs e)
+    {
+        if (e.Block.Header is not XdcBlockHeader xdcHeader)
+            return;
+
+        if (e.Block.Hash is null || !blockTree.WasProcessed(e.Block.Number, e.Block.Hash) || blockTree.IsSyncing().isSyncing)
+            return;
+
+        if (_alreadySigned.Contains(xdcHeader.Hash))
+            return;
+
+        ulong round = xdcHeader.ExtraConsensusData.BlockRound;
+        IXdcReleaseSpec spec = specProvider.GetXdcSpec(xdcHeader, round);
+        if (spec is null)
+            return;
+
+        if (xdcHeader.Number % spec.MergeSignRange != 0)
+            return;
+
+        Snapshot snapshot = snapshotManager.GetSnapshotByBlockNumber(xdcHeader.Number, spec);
+        if (snapshot is null)
+            return;
+
+        if (IsMasternode(snapshot, signer.Address))
+        {
+            _alreadySigned.Set(xdcHeader.Hash);
+            _ = SubmitTransactionSign(xdcHeader, spec)
+                .ContinueWith(t => _logger.Error("Failed to submit sign transaction", t.Exception),
+                TaskContinuationOptions.OnlyOnFaulted);
         }
     }
 
+    private static bool IsMasternode(Snapshot snapshot, Address signerAddress) =>
+        snapshot.NextEpochCandidates.AsSpan().IndexOf(signerAddress) != -1;
+
     internal static Transaction CreateTxSign(UInt256 number, Hash256 hash, UInt256 nonce, Address blockSignersAddress, Address sender)
     {
         byte[] inputData = [.. XdcConstants.SignMethod, .. number.PaddedBytes(32), .. hash.Bytes.PadLeft(32)];
@@ -50,4 +101,10 @@
 
         return transaction;
     }
+
+    public void Dispose()
+    {
+        blockTree.BlockAddedToMain -= OnBlockAddedToMain;
+        GC.SuppressFinalize(this);
+    }
 }

src/Nethermind/Nethermind.Xdc/XdcHotStuff.cs

@@ -32,7 +32,6 @@ internal class XdcHotStuff(
         ISigner signer,
         ITimeoutTimer timeoutTimer,
         IProcessExitSource processExit,
-        ISignTransactionManager signTransactionManager,
         ILogManager logManager) : IBlockProducerRunner
     {
         private readonly IBlockTree _blockTree = blockTree ?? throw new ArgumentNullException(nameof(blockTree));
@@ -48,7 +47,6 @@ internal class XdcHotStuff(
         private readonly ITimeoutTimer _timeoutTimer = timeoutTimer;
         private readonly IProcessExitSource _processExit = processExit;
         private readonly ILogger _logger = logManager?.GetClassLogger<XdcHotStuff>() ?? throw new ArgumentNullException(nameof(logManager));
-        private readonly ISignTransactionManager _signTransactionManager = signTransactionManager ?? throw new ArgumentNullException(nameof(signTransactionManager));
 
         private CancellationTokenSource? _cancellationTokenSource;
         private Task? _runTask;
@@ -60,7 +58,6 @@ internal class XdcHotStuff(
         private ulong _highestSelfMinedRound;
         private ulong _highestVotedRound;
         private bool _writeRoundInfo = true;
-        private long _highestSignTxNumber = 0;
 
         /// <summary>
         /// Starts the consensus runner.
@@ -233,17 +230,6 @@ internal async Task RunRoundChecks(CancellationToken ct)
                 Task blockBuilder = BuildAndProposeBlock(roundParent, currentRound, spec, ct);
             }
 
-            if (_highestSignTxNumber < roundParent.Number
-                && ((roundParent.Number % spec.MergeSignRange == 0)))
-            {
-                Snapshot snapshot = _snapshotManager.GetSnapshotByBlockNumber(roundParent.Number, spec);
-                if (snapshot is not null && snapshot.NextEpochCandidates.AsSpan().IndexOf(_signer.Address) != -1)
-                {
-                    _highestSignTxNumber = roundParent.Number;
-                    await _signTransactionManager.SubmitTransactionSign(roundParent, spec);
-                }
-            }
-
             _writeRoundInfo = false;
         }
 

src/Nethermind/Nethermind.Xdc/XdcModule.cs

@@ -101,7 +101,6 @@ protected override void Load(ContainerBuilder builder)
             .AddSingleton<IXdcConsensusContext, XdcConsensusContext>()
             .AddDatabase(XdcRocksDbConfigFactory.XdcSnapshotDbName)
             .AddSingleton<ISnapshotManager, IDb, IBlockTree, IMasternodeVotingContract, ISpecProvider>(CreateSnapshotManager)
-            .AddSingleton<ISignTransactionManager, ISigner, ITxPool, ILogManager>(CreateSignTransactionManager)
             .AddSingleton<IPenaltyHandler, PenaltyHandler>()
             .AddSingleton<ITimeoutTimer, TimeoutTimer>()
             .AddSingleton<ISyncInfoManager, SyncInfoManager>()
@@ -130,10 +129,11 @@ protected override void Load(ContainerBuilder builder)
             .AddSingleton<IGasLimitCalculator, XdcGasLimitCalculator>()
             .AddSingleton<IDifficultyCalculator, XdcDifficultyCalculator>()
             .AddScoped<IProducedBlockSuggester, XdcBlockSuggester>();
+
+        builder.RegisterType<SignTransactionManager>().As<IStartable>().SingleInstance();
     }
 
     private ISnapshotManager CreateSnapshotManager([KeyFilter(XdcRocksDbConfigFactory.XdcSnapshotDbName)] IDb db, IBlockTree blockTree, IMasternodeVotingContract votingContract, ISpecProvider specProvider) => new SnapshotManager(db, blockTree, votingContract, specProvider);
-    private ISignTransactionManager CreateSignTransactionManager(ISigner signer, ITxPool txPool, ILogManager logManager) => new SignTransactionManager(signer, txPool, logManager.GetClassLogger<SignTransactionManager>());
 
     private IMasternodeVotingContract CreateVotingContract(
         IAbiEncoder abiEncoder,

src/Nethermind/Nethermind.Xdc/XdcPlugin.cs

@@ -59,7 +59,6 @@ public Task InitNetworkProtocol()
             _nethermindApi.Context.Resolve<ISigner>(),
             _nethermindApi.Context.Resolve<ITimeoutTimer>(),
             _nethermindApi.ProcessExit,
-            _nethermindApi.Context.Resolve<ISignTransactionManager>(),
             _nethermindApi.Context.Resolve<ILogManager>()
             );
     public IBlockProducer InitBlockProducer()