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

@@ -550,6 +550,48 @@ where
         }
     }
 
+    /// Similar to [`AsyncTree::async_op_failure`], but uses a caller-provided timeout
+    /// instead of [`Config::retry_after_failed`].
+    pub fn async_op_failure_with_timeout(&mut self, async_op_id: AsyncOpId, retry_after: &TNow) {
+        for index in self
+            .non_finalized_blocks
+            .iter_ancestry_order()
+            .map(|(index, _)| index)
+            .collect::<Vec<_>>()
+            .into_iter()
+            .rev()
+        {
+            let new_timeout = match self.non_finalized_blocks.get_mut(index).unwrap().async_op {
+                AsyncOpState::InProgress {
+                    async_op_id: id,
+                    timeout: Some(ref timeout),
+                } 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(retry_after.clone()),
+                _ => continue,
+            };
+
+            let same_as_parent = self
+                .non_finalized_blocks
+                .parent(index)
+                .map_or(false, |idx| {
+                    match self.non_finalized_blocks.get(idx).unwrap().async_op {
+                        AsyncOpState::InProgress {
+                            async_op_id: id, ..
+                        } => id == async_op_id,
+                        _ => false,
+                    }
+                });
+
+            self.non_finalized_blocks.get_mut(index).unwrap().async_op = AsyncOpState::Pending {
+                same_as_parent,
+                timeout: new_timeout,
+            };
+        }
+    }
+
     /// Examines the state of `self` and, if a block's asynchronous operation should be started,
     /// changes the state of the block to "in progress" and returns the parameters of the
     /// operation.

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_with_timeout(async_op_id, &short_retry);
+                        }
+                        Tree::FinalizedBlockRuntimeUnknown { tree, .. } => {
+                            tree.async_op_failure_with_timeout(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 {