perf(runtime-service): use short retry when no peers available

The runtime service tries to download the finalized block runtime
immediately at startup, before peer connections are established.
This always fails with StorageQueryError { errors: [] } (no peers
to query). Previously, this triggered the full 4s retry_after_failed
cooldown, making warm start consistently ~5-7s.

Now, "no peers" errors use a 200ms retry instead of 4s. Peers
typically connect within a few hundred milliseconds, so the retry
succeeds quickly. Other errors (peer misbehavior, decode failures)
still use the full 4s cooldown.

Benchmark on Polkadot: warm start drops from ~5.5s to ~600ms.

Author: replghost

lib/src/chain/async_tree.rs

@@ -505,8 +505,13 @@ where
     /// Panics if the [`AsyncOpId`] is invalid.
     ///
     pub fn async_op_failure(&mut self, async_op_id: AsyncOpId, now: &TNow) {
-        let new_timeout = now.clone() + self.retry_after_failed;
+        let retry_after = now.clone() + self.retry_after_failed;
+        self.async_op_failure_retry_at(async_op_id, &retry_after);
+    }
 
+    /// Similar to [`AsyncTree::async_op_failure`], but retries at the given time
+    /// instead of `now + retry_after_failed`.
+    pub fn async_op_failure_retry_at(&mut self, async_op_id: AsyncOpId, retry_after: &TNow) {
         // Update the blocks that were performing this operation.
         // The blocks are iterated from child to parent, so that we can check, for each node,
         // whether its parent has the same asynchronous operation id.
@@ -523,11 +528,11 @@ where
                 AsyncOpState::InProgress {
                     async_op_id: id,
                     timeout: Some(ref timeout),
-                } if id == async_op_id => Some(cmp::min(timeout.clone(), new_timeout.clone())),
+                } if id == async_op_id => Some(cmp::min(timeout.clone(), retry_after.clone())),
                 AsyncOpState::InProgress {
                     async_op_id: id,
                     timeout: None,
-                } if id == async_op_id => Some(new_timeout.clone()),
+                } if id == async_op_id => Some(retry_after.clone()),
                 _ => continue,
             };
 

light-base/src/runtime_service.rs

@@ -2810,12 +2810,26 @@ async fn run_background<TPlat: PlatformRef>(
                     );
                 }
 
-                match &mut background.tree {
-                    Tree::FinalizedBlockRuntimeKnown { tree, .. } => {
-                        tree.async_op_failure(async_op_id, &background.platform.now());
+                if error.is_no_peers() {
+                    // No peers available yet — use a short retry (200ms) instead of
+                    // the full 4s cooldown. Peers typically connect within milliseconds.
+                    let short_retry = background.platform.now() + Duration::from_millis(200);
+                    match &mut background.tree {
+                        Tree::FinalizedBlockRuntimeKnown { tree, .. } => {
+                            tree.async_op_failure_retry_at(async_op_id, &short_retry);
+                        }
+                        Tree::FinalizedBlockRuntimeUnknown { tree, .. } => {
+                            tree.async_op_failure_retry_at(async_op_id, &short_retry);
+                        }
                     }
-                    Tree::FinalizedBlockRuntimeUnknown { tree, .. } => {
-                        tree.async_op_failure(async_op_id, &background.platform.now());
+                } else {
+                    match &mut background.tree {
+                        Tree::FinalizedBlockRuntimeKnown { tree, .. } => {
+                            tree.async_op_failure(async_op_id, &background.platform.now());
+                        }
+                        Tree::FinalizedBlockRuntimeUnknown { tree, .. } => {
+                            tree.async_op_failure(async_op_id, &background.platform.now());
+                        }
                     }
                 }
             }
@@ -2832,6 +2846,13 @@ enum RuntimeDownloadError {
 }
 
 impl RuntimeDownloadError {
+    fn is_no_peers(&self) -> bool {
+        match self {
+            RuntimeDownloadError::StorageQuery(err) => err.is_no_peers(),
+            RuntimeDownloadError::InvalidHeader(_) => false,
+        }
+    }
+
     /// Returns `true` if this is caused by networking issues, as opposed to a consensus-related
     /// issue.
     fn is_network_problem(&self) -> bool {

light-base/src/sync_service.rs

@@ -1040,6 +1040,11 @@ pub struct StorageQueryError {
 }
 
 impl StorageQueryError {
+    /// Returns `true` if no peers were available to query.
+    pub fn is_no_peers(&self) -> bool {
+        self.errors.is_empty()
+    }
+
     /// Returns `true` if this is caused by networking issues, as opposed to a consensus-related
     /// issue.
     pub fn is_network_problem(&self) -> bool {