feat: implement support for maxBlocksBehind threshold check in Tracer…

…ReadinessPlugin

arithmetization/src/main/java/net/consensys/linea/plugins/BesuServiceProvider.java

@@ -16,6 +16,7 @@
 package net.consensys.linea.plugins;
 
 import org.hyperledger.besu.plugin.BesuContext;
+import org.hyperledger.besu.plugin.services.BesuEvents;
 import org.hyperledger.besu.plugin.services.BesuService;
 import org.hyperledger.besu.plugin.services.PicoCLIOptions;
 import org.hyperledger.besu.plugin.services.RpcEndpointService;
@@ -55,4 +56,8 @@ public static RpcEndpointService getRpcEndpointService(final BesuContext context
   public static SynchronizationService getSynchronizationService(final BesuContext context) {
     return getBesuService(context, SynchronizationService.class);
   }
+
+  public static BesuEvents getBesuEventsService(final BesuContext context) {
+    return getBesuService(context, BesuEvents.class);
+  }
 }

arithmetization/src/main/java/net/consensys/linea/plugins/readiness/TracerReadinessCliOptions.java

@@ -24,21 +24,34 @@ public class TracerReadinessCliOptions implements LineaCliOptions {
 
   static final String TRACER_READINESS_SERVER_HOST = "--plugin-linea-tracer-readiness-server-host";
   static final String TRACER_READINESS_SERVER_PORT = "--plugin-linea-tracer-readiness-server-port";
+  static final String TRACER_READINESS_MAX_BLOCKS_BEHIND =
+      "--plugin-linea-tracer-readiness-max-blocks-behind";
 
   @CommandLine.Option(
+      required = true,
       names = {TRACER_READINESS_SERVER_PORT},
       hidden = true,
       paramLabel = "<SERVER_PORT>",
       description = "HTTP server port for tracer readiness plugin")
   private int serverPort = 8548;
 
   @CommandLine.Option(
+      required = true,
       names = {TRACER_READINESS_SERVER_HOST},
       hidden = true,
       paramLabel = "<SERVER_HOST>",
       description = "HTTP server host for tracer readiness plugin")
   private String serverHost = "0.0.0.0";
 
+  @CommandLine.Option(
+      required = true,
+      names = {TRACER_READINESS_MAX_BLOCKS_BEHIND},
+      hidden = true,
+      paramLabel = "<BLOCK_COUNT>",
+      description =
+          "Maximum number of block behind the head of the chain to treat negligible in state sync")
+  private int maxBlocksBehind;
+
   private TracerReadinessCliOptions() {}
 
   /**
@@ -60,6 +73,7 @@ static TracerReadinessCliOptions fromConfig(final TracerReadinessConfiguration c
     final TracerReadinessCliOptions options = create();
     options.serverHost = config.serverHost();
     options.serverPort = config.serverPort();
+    options.maxBlocksBehind = config.maxBlocksBehind();
     return options;
   }
 
@@ -73,6 +87,7 @@ public TracerReadinessConfiguration toDomainObject() {
     return TracerReadinessConfiguration.builder()
         .serverHost(serverHost)
         .serverPort(serverPort)
+        .maxBlocksBehind(maxBlocksBehind)
         .build();
   }
 
@@ -81,6 +96,7 @@ public String toString() {
     return MoreObjects.toStringHelper(this)
         .add(TRACER_READINESS_SERVER_HOST, serverHost)
         .add(TRACER_READINESS_SERVER_PORT, serverPort)
+        .add(TRACER_READINESS_MAX_BLOCKS_BEHIND, maxBlocksBehind)
         .toString();
   }
 }

arithmetization/src/main/java/net/consensys/linea/plugins/readiness/TracerReadinessConfiguration.java

@@ -20,5 +20,5 @@
 
 /** The Linea tracer configuration private to this repo. */
 @Builder(toBuilder = true)
-public record TracerReadinessConfiguration(String serverHost, int serverPort)
+public record TracerReadinessConfiguration(String serverHost, int serverPort, int maxBlocksBehind)
     implements LineaOptionsConfiguration {}

arithmetization/src/main/java/net/consensys/linea/plugins/readiness/TracerReadinessPlugin.java

@@ -19,6 +19,7 @@
 
 import java.util.Map;
 import java.util.Optional;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 import com.google.auto.service.AutoService;
 import io.vertx.core.Vertx;
@@ -40,9 +41,13 @@
 @AutoService(BesuPlugin.class)
 public class TracerReadinessPlugin extends AbstractLineaOptionsPlugin {
   private static final String TRACER_READINESS_ENDPOINT_NAME = "/tracer-readiness";
+
+  private final AtomicBoolean isInSync = new AtomicBoolean(true);
+
   private SynchronizationService synchronizationService;
   private HttpServer server;
   private BesuContext besuContext;
+  private TracerReadinessConfiguration configuration;
 
   /**
    * Register the needed Besu services.
@@ -53,6 +58,22 @@ public class TracerReadinessPlugin extends AbstractLineaOptionsPlugin {
   public void register(final BesuContext context) {
     super.register(context);
     this.besuContext = context;
+
+    this.configuration =
+        (TracerReadinessConfiguration)
+            getConfigurationByKey(TracerReadinessCliOptions.CONFIG_KEY).optionsConfig();
+
+    BesuServiceProvider.getBesuEventsService(context)
+        .addSyncStatusListener(
+            syncStatus ->
+                syncStatus.ifPresent(
+                    status -> {
+                      boolean isInMaxBlockBehindRange =
+                          status.getHighestBlock() - status.getCurrentBlock()
+                              <= configuration.maxBlocksBehind();
+
+                      isInSync.set(isInMaxBlockBehindRange);
+                    }));
   }
 
   @Override
@@ -81,10 +102,6 @@ public void start() {
               }
             });
 
-    TracerReadinessConfiguration configuration =
-        (TracerReadinessConfiguration)
-            getConfigurationByKey(TracerReadinessCliOptions.CONFIG_KEY).optionsConfig();
-
     // Start the Vertx HTTP server
     server =
         vertx
@@ -117,6 +134,7 @@ private HttpServerOptions httpServerOptions(final TracerReadinessConfiguration c
   }
 
   private boolean isTracerReady() {
+    // This service cannot be initialized in register method.
     this.synchronizationService =
         Optional.ofNullable(synchronizationService)
             .orElse(BesuServiceProvider.getSynchronizationService(besuContext));
@@ -125,7 +143,9 @@ private boolean isTracerReady() {
         RequestLimiterDispatcher.getLimiter(
             RequestLimiterDispatcher.SINGLE_INSTANCE_REQUEST_LIMITER_KEY);
 
-    return !requestLimiter.isNodeAtMaxCapacity() && synchronizationService.isInitialSyncPhaseDone();
+    return synchronizationService.isInitialSyncPhaseDone()
+        && isInSync.get()
+        && !requestLimiter.isNodeAtMaxCapacity();
   }
 
   @Override