Sequencer - Added sorting by ftx number before adding to the pool

Author: Filter94

besu-plugins/linea-sequencer/sequencer/src/main/java/net/consensys/linea/rpc/methods/LineaSendForcedRawTransaction.java

@@ -12,6 +12,7 @@
 import com.fasterxml.jackson.annotation.JsonInclude;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import java.util.ArrayList;
+import java.util.Comparator;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
@@ -169,6 +170,8 @@ public List<ForcedTransactionResponse> execute(final PluginRpcRequest request) {
       }
 
       if (!forcedTransactions.isEmpty()) {
+        forcedTransactions.sort(
+            Comparator.comparingLong(ForcedTransaction::forcedTransactionNumber));
         forcedTransactionPoolService.addForcedTransactions(forcedTransactions);
       }
 

besu-plugins/linea-sequencer/sequencer/src/test/java/net/consensys/linea/rpc/methods/LineaSendForcedRawTransactionTest.java

@@ -13,15 +13,18 @@
 import static org.mockito.ArgumentMatchers.anyList;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
+import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;
 import net.consensys.linea.rpc.methods.LineaSendForcedRawTransaction.ForcedTransactionResponse;
+import net.consensys.linea.sequencer.forced.ForcedTransaction;
 import net.consensys.linea.sequencer.forced.ForcedTransactionPoolService;
 import net.consensys.linea.sequencer.forced.LineaForcedTransactionPool;
 import net.consensys.linea.utils.TestTransactionFactory;
@@ -241,6 +244,40 @@ void execute_partialSuccessWhenMiddleTransactionFails() {
     assertThat(pool.pendingCount()).isEqualTo(2);
   }
 
+  @Test
+  void execute_sortsTransactionsByForcedTransactionNumberBeforeAddingToPool() {
+    final List<ForcedTransaction> capturedTransactions = new ArrayList<>();
+    final ForcedTransactionPoolService mockPool = mock(ForcedTransactionPoolService.class);
+    doAnswer(
+            invocation -> {
+              capturedTransactions.addAll(invocation.getArgument(0));
+              return null;
+            })
+        .when(mockPool)
+        .addForcedTransactions(anyList());
+
+    final LineaSendForcedRawTransaction methodWithMock =
+        new LineaSendForcedRawTransaction().init(mockPool);
+
+    final Transaction tx1 = txFactory.createTransaction();
+    final Transaction tx2 = txFactory.createTransaction();
+    final Transaction tx3 = txFactory.createTransaction();
+
+    // Submit transactions out of order: 9, 5, 7
+    methodWithMock.execute(
+        request(
+            new ForcedTxParam(9L, TestTransactionFactory.encodeTransaction(tx1), "0x1000"),
+            new ForcedTxParam(5L, TestTransactionFactory.encodeTransaction(tx2), "0x2000"),
+            new ForcedTxParam(7L, TestTransactionFactory.encodeTransaction(tx3), "0x3000")));
+
+    verify(mockPool).addForcedTransactions(anyList());
+    assertThat(capturedTransactions).hasSize(3);
+    // Verify they are sorted by forcedTransactionNumber: 5, 7, 9
+    assertThat(capturedTransactions.get(0).forcedTransactionNumber()).isEqualTo(5L);
+    assertThat(capturedTransactions.get(1).forcedTransactionNumber()).isEqualTo(7L);
+    assertThat(capturedTransactions.get(2).forcedTransactionNumber()).isEqualTo(9L);
+  }
+
   @Test
   void execute_rejectsConcurrentRequests() throws Exception {
     // Use a mock pool that blocks to simulate slow processing