fix(core): fail fast if provider fails to provide a block

core/src/block_strider/mod.rs

@@ -141,6 +141,7 @@ where
             JoinTask::new(self.fetch_next_master_block(&self.state.load_last_mc_block_id()));
 
         while let Some(next) = next_master_fut.await {
+            let next = next?;
             // NOTE: Start fetching the next master block in parallel to the processing of the current one
             next_master_fut = JoinTask::new(self.fetch_next_master_block(next.id()));
 
@@ -299,41 +300,34 @@ where
     fn fetch_next_master_block(
         &self,
         prev_block_id: &BlockId,
-    ) -> impl Future<Output = Option<BlockStuffAug>> + Send + 'static {
+    ) -> impl Future<Output = OptionalBlockStuff> + Send + 'static {
         let _histogram = HistogramGuard::begin("tycho_core_download_mc_block_time");
 
         tracing::debug!(%prev_block_id, "fetching next master block");
 
         let provider = self.provider.clone();
         let prev_block_id = *prev_block_id;
         async move {
-            loop {
-                match provider.get_next_block(&prev_block_id).await? {
-                    Ok(block) => break Some(block),
-                    Err(e) => {
-                        tracing::error!(?prev_block_id, "error while fetching master block: {e:?}");
-                        // TODO: backoff
-
-                        // NOTE: Give some time to breathe to tokio
-                        tokio::task::yield_now().await;
-                    }
-                }
-            }
+            provider.get_next_block(&prev_block_id).await.map(|r| {
+                r.map_err(|e| {
+                    e.context(format!(
+                        "BUGGY PROVIDER. failed to fetch master block: {}",
+                        prev_block_id
+                    ))
+                })
+            })
         }
     }
 
     async fn fetch_block(&self, block_id: &BlockId) -> Result<BlockStuffAug> {
-        loop {
-            match self.provider.get_block(block_id).await {
-                Some(Ok(block)) => break Ok(block),
-                Some(Err(e)) => {
-                    tracing::error!("error while fetching block: {e:?}");
-                    tokio::task::yield_now().await;
-                    // TODO: backoff
-                }
-                None => {
-                    anyhow::bail!("block not found: {block_id}")
-                }
+        match self.provider.get_block(block_id).await {
+            Some(Ok(block)) => Ok(block),
+            Some(Err(e)) => Err(e.context(format!(
+                "BUGGY PROVIDER. failed to fetch block: {}",
+                block_id
+            ))),
+            None => {
+                anyhow::bail!("block not found: {block_id}")
             }
         }
     }