apollo_l1_gas_price: start scraper with a loop to find start block, instead of panic if it fails

Author: guy-starkware

crates/apollo_l1_gas_price/src/l1_gas_price_scraper.rs

@@ -12,7 +12,7 @@ use async_trait::async_trait;
 use papyrus_base_layer::{BaseLayerContract, L1BlockHeader, L1BlockNumber};
 use starknet_api::block::GasPrice;
 use thiserror::Error;
-use tracing::{error, info, trace};
+use tracing::{error, info, trace, warn};
 
 use crate::metrics::{
     register_scraper_metrics,
@@ -63,6 +63,32 @@ impl<B: BaseLayerContract + Send + Sync + Debug> L1GasPriceScraper<B> {
         Self { config, l1_gas_price_provider, base_layer, last_l1_header: None }
     }
 
+    pub async fn get_first_block_then_run(&mut self) -> L1GasPriceScraperResult<(), B> {
+        let start_from = loop {
+            match self.config.starting_block {
+                Some(block) => break block,
+                None => {
+                    let latest = self.latest_l1_block_number().await;
+                    let Ok(latest) = latest else {
+                        warn!("Failed to get the latest L1 block number at startup: {latest:?}");
+                        tokio::time::sleep(self.config.polling_interval).await;
+                        continue;
+                    };
+                    // If no starting block is provided, the default is to start from
+                    // startup_num_blocks_multiplier * number_of_blocks_for_mean before the tip of
+                    // L1. Note that for new chains this subtraction may be
+                    // negative, hence the use of saturating_sub.
+                    let latest = latest.saturating_sub(
+                        self.config.number_of_blocks_for_mean
+                            * self.config.startup_num_blocks_multiplier,
+                    );
+                    break latest;
+                }
+            }
+        };
+        self.run(start_from).await
+    }
+
     /// Run the scraper, starting from the given L1 `block_number`, indefinitely.
     pub async fn run(&mut self, mut block_number: L1BlockNumber) -> L1GasPriceScraperResult<(), B> {
         self.l1_gas_price_provider
@@ -174,24 +200,8 @@ where
     async fn start(&mut self) {
         info!("Starting component {}.", type_name::<Self>());
         register_scraper_metrics();
-        let start_from = match self.config.starting_block {
-            Some(block) => block,
-            None => {
-                let latest = self
-                    .latest_l1_block_number()
-                    .await
-                    .expect("Failed to get the latest L1 block number at startup");
-
-                // If no starting block is provided, the default is to start from
-                // startup_num_blocks_multiplier * number_of_blocks_for_mean before the tip of L1.
-                // Note that for new chains this subtraction may be negative,
-                // hence the use of saturating_sub.
-                latest.saturating_sub(
-                    self.config.number_of_blocks_for_mean
-                        * self.config.startup_num_blocks_multiplier,
-                )
-            }
-        };
-        self.run(start_from).await.unwrap_or_else(|e| panic!("L1 gas price scraper failed: {e}"))
+        self.get_first_block_then_run()
+            .await
+            .unwrap_or_else(|e| panic!("L1 gas price scraper failed: {e}"))
     }
 }

crates/apollo_l1_gas_price/src/l1_gas_price_scraper_test.rs

@@ -1,9 +1,11 @@
 use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 use std::sync::Arc;
+use std::time::Duration;
 
+use apollo_l1_gas_price_types::errors::{L1GasPriceClientError, L1GasPriceProviderError};
 use apollo_l1_gas_price_types::{GasPriceData, MockL1GasPriceProviderClient};
 use assert_matches::assert_matches;
-use papyrus_base_layer::{L1BlockHash, L1BlockHeader, MockBaseLayerContract};
+use papyrus_base_layer::{L1BlockHash, L1BlockHeader, MockBaseLayerContract, MockError};
 use rstest::rstest;
 use starknet_api::block::GasPrice;
 
@@ -323,4 +325,29 @@ async fn base_layer_returns_block_number_below_finality_causes_error() {
     );
 }
 
+#[tokio::test]
+async fn get_first_block_then_run_fails_then_succeeds() {
+    let mut mock_contract = MockBaseLayerContract::new();
+    mock_contract
+        .expect_latest_l1_block_number()
+        .times(1)
+        .returning(move || Err(MockError::MockError));
+    mock_contract.expect_latest_l1_block_number().times(1).returning(move || Ok(1));
+
+    // The provider will return an error, indicating the scraper has successfully started running.
+    // The error will take us out of the endless loop of scraper.run().
+    let mut mock_provider = MockL1GasPriceProviderClient::new();
+    mock_provider.expect_initialize().times(1).returning(move || {
+        Err(L1GasPriceClientError::L1GasPriceProviderError(
+            L1GasPriceProviderError::UnexpectedBlockNumberError { expected: 0, found: 1 },
+        ))
+    });
+    let mut scraper = L1GasPriceScraper::new(
+        L1GasPriceScraperConfig { polling_interval: Duration::from_secs(0), ..Default::default() },
+        Arc::new(mock_provider),
+        mock_contract,
+    );
+    assert!(scraper.get_first_block_then_run().await.is_err());
+}
+
 // TODO(guyn): test scraper with a provider timeout