Disable NonceGap check for internal transactions

src/Nethermind/Nethermind.Api/IApiWithBlockchain.cs

@@ -65,6 +65,7 @@ public interface IApiWithBlockchain : IApiWithStores, IBlockchainBridgeFactory
         ITransactionProcessor? TransactionProcessor { get; set; }
         ITrieStore? TrieStore { get; set; }
         ITxSender? TxSender { get; set; }
+        INonceManager? NonceManager { get; set; }
         ITxPool? TxPool { get; set; }
         ITxPoolInfoProvider? TxPoolInfoProvider { get; set; }
         IWitnessCollector? WitnessCollector { get; set; }

src/Nethermind/Nethermind.Api/NethermindApi.cs

@@ -197,6 +197,7 @@ public ISealEngine SealEngine
         public ITrieStore? TrieStore { get; set; }
         public IReadOnlyTrieStore? ReadOnlyTrieStore { get; set; }
         public ITxSender? TxSender { get; set; }
+        public INonceManager? NonceManager { get; set; }
         public ITxPool? TxPool { get; set; }
         public ITxPoolInfoProvider? TxPoolInfoProvider { get; set; }
         public IHealthHintService? HealthHintService { get; set; }

src/Nethermind/Nethermind.Consensus.AuRa/InitializationSteps/InitializeBlockchainAuRa.cs

@@ -116,6 +116,7 @@ private IAuRaValidator CreateAuRaValidator(IBlockProcessor processor, IReadOnlyT
             if (_api.BlockTree is null) throw new StepDependencyException(nameof(_api.BlockTree));
             if (_api.EngineSigner is null) throw new StepDependencyException(nameof(_api.EngineSigner));
             if (_api.SpecProvider is null) throw new StepDependencyException(nameof(_api.SpecProvider));
+            if (_api.NonceManager is null) throw new StepDependencyException(nameof(_api.NonceManager));
 
             var chainSpecAuRa = _api.ChainSpec.AuRa;
 
@@ -136,8 +137,7 @@ private IAuRaValidator CreateAuRaValidator(IBlockProcessor processor, IReadOnlyT
                     _api.ReceiptStorage,
                     _api.ValidatorStore,
                     _api.FinalizationManager,
-                    new TxPoolSender(_api.TxPool,
-                    new NonceReservingTxSealer(_api.EngineSigner, _api.Timestamper, _api.TxPool, _api.EthereumEcdsa)),
+                    new TxPoolSender(_api.TxPool, new TxSealer(_api.EngineSigner, _api.Timestamper), _api.NonceManager, _api.EthereumEcdsa),
                     _api.TxPool,
                     NethermindApi.Config<IBlocksConfig>(),
                     _api.LogManager,

src/Nethermind/Nethermind.Core.Test/Blockchain/TestBlockchain.cs

@@ -43,6 +43,7 @@ public class TestBlockchain : IDisposable
     public const int DefaultTimeout = 4000;
     public IStateReader StateReader { get; private set; } = null!;
     public IEthereumEcdsa EthereumEcdsa { get; private set; } = null!;
+    public INonceManager NonceManager { get; private set; } = null!;
     public TransactionProcessor TxProcessor { get; set; } = null!;
     public IStorageProvider Storage { get; set; } = null!;
     public IReceiptStorage ReceiptStorage { get; set; } = null!;
@@ -142,6 +143,11 @@ protected virtual async Task<TestBlockchain> Build(ISpecProvider? specProvider =
         TransactionComparerProvider = new TransactionComparerProvider(SpecProvider, BlockTree);
         TxPool = CreateTxPool();
 
+        IChainHeadInfoProvider chainHeadInfoProvider =
+            new ChainHeadInfoProvider(SpecProvider, BlockTree, StateReader);
+
+        NonceManager = new NonceManager(chainHeadInfoProvider.AccountStateProvider);
+
         _trieStoreWatcher = new TrieStoreBoundaryWatcher(TrieStore, BlockTree, LogManager);
 
         ReceiptStorage = new InMemoryReceiptStorage();

src/Nethermind/Nethermind.Facade.Test/TxPoolBridgeTests.cs

@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited
 // SPDX-License-Identifier: LGPL-3.0-only
 
+using System.Threading;
 using FluentAssertions;
 using Nethermind.Consensus;
 using Nethermind.Core;
@@ -19,19 +20,23 @@ public class TxPoolBridgeTests
         private ITxSender _txSender;
         private ITxPool _txPool;
         private ITxSigner _txSigner;
+        private INonceManager _nonceManager;
+        private IEthereumEcdsa _ecdsa;
 
         [SetUp]
         public void SetUp()
         {
             _txPool = Substitute.For<ITxPool>();
             _txSigner = Substitute.For<ITxSigner>();
-            _txSender = new TxPoolSender(_txPool, new TxSealer(_txSigner, Timestamper.Default));
+            _nonceManager = new NonceManager(Substitute.For<IAccountStateProvider>());
+            _ecdsa = Substitute.For<IEthereumEcdsa>();
+            _txSender = new TxPoolSender(_txPool, new TxSealer(_txSigner, Timestamper.Default), _nonceManager, _ecdsa);
         }
 
         [Test]
         public void Timestamp_is_set_on_transactions()
         {
-            Transaction tx = Build.A.Transaction.Signed(new EthereumEcdsa(TestBlockchainIds.ChainId, LimboLogs.Instance), TestItem.PrivateKeyA).TestObject;
+            Transaction tx = Build.A.Transaction.WithSenderAddress(TestItem.AddressA).Signed(new EthereumEcdsa(TestBlockchainIds.ChainId, LimboLogs.Instance), TestItem.PrivateKeyA).TestObject;
             _txSender.SendTransaction(tx, TxHandlingOptions.PersistentBroadcast);
             _txPool.Received().SubmitTx(Arg.Is<Transaction>(tx => tx.Timestamp != UInt256.Zero), TxHandlingOptions.PersistentBroadcast);
         }

src/Nethermind/Nethermind.Init/Steps/InitializeBlockchain.cs

@@ -245,6 +245,15 @@ private Task InitBlockchain()
 
             IChainHeadInfoProvider chainHeadInfoProvider =
                 new ChainHeadInfoProvider(getApi.SpecProvider, getApi.BlockTree, stateReader);
+
+            // TODO: can take the tx sender from plugin here maybe
+            ITxSigner txSigner = new WalletTxSigner(getApi.Wallet, getApi.SpecProvider.ChainId);
+            TxSealer nonceReservingTxSealer =
+                new(txSigner, getApi.Timestamper);
+            INonceManager nonceManager = new NonceManager(chainHeadInfoProvider.AccountStateProvider);
+            setApi.NonceManager = nonceManager;
+            setApi.TxSender = new TxPoolSender(txPool, nonceReservingTxSealer, nonceManager, getApi.EthereumEcdsa!);
+
             setApi.TxPoolInfoProvider = new TxPoolInfoProvider(chainHeadInfoProvider.AccountStateProvider, txPool);
             setApi.GasPriceOracle = new GasPriceOracle(getApi.BlockTree, getApi.SpecProvider, _api.LogManager, blocksConfig.MinGasPrice);
             IBlockProcessor mainBlockProcessor = setApi.MainBlockProcessor = CreateBlockProcessor();
@@ -265,12 +274,6 @@ private Task InitBlockchain()
             setApi.BlockchainProcessor = blockchainProcessor;
             setApi.EthSyncingInfo = new EthSyncingInfo(getApi.BlockTree, getApi.ReceiptStorage!, syncConfig, getApi.LogManager);
 
-            // TODO: can take the tx sender from plugin here maybe
-            ITxSigner txSigner = new WalletTxSigner(getApi.Wallet, getApi.SpecProvider.ChainId);
-            NonceReservingTxSealer nonceReservingTxSealer =
-                new(txSigner, getApi.Timestamper, txPool, getApi.EthereumEcdsa!);
-            setApi.TxSender = new TxPoolSender(txPool, nonceReservingTxSealer);
-
             IFilterStore filterStore = setApi.FilterStore = new FilterStore();
             setApi.FilterManager = new FilterManager(filterStore, mainBlockProcessor, txPool, getApi.LogManager);
             setApi.HealthHintService = CreateHealthHintService();

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

@@ -971,7 +971,8 @@ public async Task Send_transaction_with_signature_will_not_try_to_sign()
     public async Task Send_raw_transaction_will_send_transaction(string rawTransaction)
     {
         using Context ctx = await Context.Create();
-        ITxSender txSender = Substitute.ForPartsOf<TxPoolSender>(ctx.Test.TxPool, ctx.Test.TxSealer);
+        ITxSender txSender = Substitute.ForPartsOf<TxPoolSender>(ctx.Test.TxPool, ctx.Test.TxSealer,
+            ctx.Test.NonceManager, ctx.Test.EthereumEcdsa);
         IBlockchainBridge bridge = Substitute.For<IBlockchainBridge>();
         ctx.Test = await TestRpcBlockchain.ForTest(SealEngineType.NethDev).WithBlockchainBridge(bridge).WithTxSender(txSender).Build();
         string serialized = ctx.Test.TestEthRpc("eth_sendRawTransaction", rawTransaction);

src/Nethermind/Nethermind.JsonRpc.Test/Modules/TestRpcBlockchain.cs

@@ -126,8 +126,8 @@ protected override async Task<TestBlockchain> Build(ISpecProvider? specProvider
 
 
             ITxSigner txSigner = new WalletTxSigner(TestWallet, specProvider.ChainId);
-            TxSealer = new NonceReservingTxSealer(txSigner, Timestamper, TxPool, EthereumEcdsa ?? new EthereumEcdsa(specProvider.ChainId, LogManager));
-            TxSender ??= new TxPoolSender(TxPool, TxSealer);
+            TxSealer = new TxSealer(txSigner, Timestamper);
+            TxSender ??= new TxPoolSender(TxPool, TxSealer, NonceManager, EthereumEcdsa ?? new EthereumEcdsa(specProvider.ChainId, LogManager));
             GasPriceOracle ??= new GasPriceOracle(BlockFinder, SpecProvider, LogManager);
             FeeHistoryOracle ??= new FeeHistoryOracle(BlockFinder, ReceiptStorage, SpecProvider);
             ISyncConfig syncConfig = new SyncConfig();

src/Nethermind/Nethermind.TxPool.Test/NonceManagerTests.cs

@@ -0,0 +1,225 @@
+// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using System;
+using System.Collections.Concurrent;
+using System.Linq;
+using System.Threading.Tasks;
+using FluentAssertions;
+using Nethermind.Blockchain;
+using Nethermind.Core;
+using Nethermind.Core.Specs;
+using Nethermind.Core.Test.Builders;
+using Nethermind.Db;
+using Nethermind.Int256;
+using Nethermind.Logging;
+using Nethermind.Specs;
+using Nethermind.State;
+using Nethermind.Trie.Pruning;
+using NSubstitute;
+using NUnit.Framework;
+
+namespace Nethermind.TxPool.Test;
+
+public class NonceManagerTests
+{
+    private ISpecProvider _specProvider;
+    private IStateProvider _stateProvider;
+    private IBlockTree _blockTree;
+    private ChainHeadInfoProvider _headInfo;
+    private INonceManager _nonceManager;
+
+    [SetUp]
+    public void Setup()
+    {
+        ILogManager logManager = LimboLogs.Instance;
+        _specProvider = RopstenSpecProvider.Instance;
+        var trieStore = new TrieStore(new MemDb(), logManager);
+        var codeDb = new MemDb();
+        _stateProvider = new StateProvider(trieStore, codeDb, logManager);
+        _blockTree = Substitute.For<IBlockTree>();
+        Block block = Build.A.Block.WithNumber(0).TestObject;
+        _blockTree.Head.Returns(block);
+        _blockTree.FindBestSuggestedHeader().Returns(Build.A.BlockHeader.WithNumber(10000000).TestObject);
+
+        _headInfo = new ChainHeadInfoProvider(_specProvider, _blockTree, _stateProvider);
+        _nonceManager = new NonceManager(_headInfo.AccountStateProvider);
+    }
+
+    [Test]
+    public void should_increment_own_transaction_nonces_locally_when_requesting_reservations()
+    {
+        using (NonceLocker locker = _nonceManager.ReserveNonce(TestItem.AddressA, out UInt256 nonce))
+        {
+            nonce.Should().Be(0);
+            locker.Accept();
+        }
+
+        using (NonceLocker locker = _nonceManager.ReserveNonce(TestItem.AddressA, out UInt256 nonce))
+        {
+            nonce.Should().Be(1);
+        }
+
+        using (NonceLocker locker = _nonceManager.ReserveNonce(TestItem.AddressA, out UInt256 nonce))
+        {
+            nonce.Should().Be(1);
+            locker.Accept();
+        }
+
+        using (NonceLocker locker = _nonceManager.ReserveNonce(TestItem.AddressB, out UInt256 nonce))
+        {
+            nonce.Should().Be(0);
+            locker.Accept();
+        }
+
+        using (NonceLocker locker = _nonceManager.ReserveNonce(TestItem.AddressB, out UInt256 nonce))
+        {
+            nonce.Should().Be(1);
+            locker.Accept();
+        }
+
+        using (NonceLocker locker = _nonceManager.ReserveNonce(TestItem.AddressB, out UInt256 nonce))
+        {
+            nonce.Should().Be(2);
+        }
+
+        using (NonceLocker locker = _nonceManager.ReserveNonce(TestItem.AddressB, out UInt256 nonce))
+        {
+            nonce.Should().Be(2);
+            locker.Accept();
+        }
+    }
+
+    [Test]
+    [Repeat(10)]
+    public void should_increment_own_transaction_nonces_locally_when_requesting_reservations_in_parallel()
+    {
+        const int reservationsCount = 1000;
+
+        ConcurrentQueue<UInt256> nonces = new();
+
+        var result = Parallel.For(0, reservationsCount, i =>
+        {
+            using NonceLocker locker = _nonceManager.ReserveNonce(TestItem.AddressA, out UInt256 nonce);
+            locker.Accept();
+            nonces.Enqueue(nonce);
+        });
+
+        result.IsCompleted.Should().BeTrue();
+        using NonceLocker locker = _nonceManager.ReserveNonce(TestItem.AddressA, out UInt256 nonce);
+        nonces.Enqueue(nonce);
+        nonce.Should().Be(new UInt256(reservationsCount));
+        nonces.OrderBy(n => n).Should().BeEquivalentTo(Enumerable.Range(0, reservationsCount + 1).Select(i => new UInt256((uint)i)));
+    }
+
+    [Test]
+    public void should_pick_account_nonce_as_initial_value()
+    {
+        IAccountStateProvider accountStateProvider = Substitute.For<IAccountStateProvider>();
+        Account account = new(0);
+        accountStateProvider.GetAccount(TestItem.AddressA).Returns(account);
+        _nonceManager = new NonceManager(accountStateProvider);
+        using (NonceLocker locker = _nonceManager.ReserveNonce(TestItem.AddressA, out UInt256 nonce))
+        {
+            nonce.Should().Be(0);
+        }
+
+        accountStateProvider.GetAccount(TestItem.AddressA).Returns(account.WithChangedNonce(10));
+        using (NonceLocker locker = _nonceManager.ReserveNonce(TestItem.AddressA, out UInt256 nonce))
+        {
+            nonce.Should().Be(10);
+        }
+    }
+
+    [Test]
+    public void ReserveNonce_should_skip_nonce_if_TxWithNonceReceived()
+    {
+        using (NonceLocker locker = _nonceManager.TxWithNonceReceived(TestItem.AddressA, 4))
+        {
+            locker.Accept();
+        }
+
+        using (NonceLocker locker = _nonceManager.ReserveNonce(TestItem.AddressA, out UInt256 nonce))
+        {
+            nonce.Should().Be(0);
+            locker.Accept();
+        }
+
+        using (NonceLocker locker = _nonceManager.ReserveNonce(TestItem.AddressA, out UInt256 nonce))
+        {
+            nonce.Should().Be(1);
+            locker.Accept();
+        }
+
+        using (NonceLocker locker = _nonceManager.TxWithNonceReceived(TestItem.AddressA, 2))
+        {
+            locker.Accept();
+        }
+
+        using (NonceLocker locker = _nonceManager.ReserveNonce(TestItem.AddressA, out UInt256 nonce))
+        {
+            nonce.Should().Be(3);
+            locker.Accept();
+        }
+
+        using (NonceLocker locker = _nonceManager.ReserveNonce(TestItem.AddressA, out UInt256 nonce))
+        {
+            nonce.Should().Be(5);
+            locker.Accept();
+        }
+    }
+
+    [Test]
+    public void should_reuse_nonce_if_tx_rejected()
+    {
+        using (NonceLocker locker = _nonceManager.ReserveNonce(TestItem.AddressA, out UInt256 nonce))
+        {
+            nonce.Should().Be(0);
+        }
+
+        using (NonceLocker locker = _nonceManager.ReserveNonce(TestItem.AddressA, out UInt256 nonce))
+        {
+            nonce.Should().Be(0);
+            locker.Accept();
+        }
+
+        using (NonceLocker locker = _nonceManager.TxWithNonceReceived(TestItem.AddressA, 1)) { }
+
+        using (NonceLocker locker = _nonceManager.ReserveNonce(TestItem.AddressA, out UInt256 nonce))
+        {
+            nonce.Should().Be(1);
+            locker.Accept();
+        }
+    }
+
+    [Test]
+    [Repeat(10)]
+    public void should_lock_on_same_account()
+    {
+        using NonceLocker locker = _nonceManager.ReserveNonce(TestItem.AddressA, out UInt256 nonce);
+        nonce.Should().Be(0);
+        Task task = Task.Run(() =>
+        {
+            using NonceLocker locker = _nonceManager.ReserveNonce(TestItem.AddressA, out UInt256 _);
+        });
+        TimeSpan ts = TimeSpan.FromMilliseconds(1000);
+        task.Wait(ts);
+        task.IsCompleted.Should().Be(false);
+    }
+
+    [Test]
+    [Repeat(10)]
+    public void should_not_lock_on_different_accounts()
+    {
+        using NonceLocker locker = _nonceManager.ReserveNonce(TestItem.AddressA, out UInt256 nonce);
+        nonce.Should().Be(0);
+        Task task = Task.Run(() =>
+        {
+            using NonceLocker locker2 = _nonceManager.ReserveNonce(TestItem.AddressB, out UInt256 nonce2);
+            nonce2.Should().Be(0);
+        });
+        TimeSpan ts = TimeSpan.FromMilliseconds(1000);
+        task.Wait(ts);
+        task.IsCompleted.Should().Be(true);
+    }
+}