apollo_l1_provider: add uninitialized state to provider (#9571)

Author: guy-starkware

crates/apollo_l1_provider/src/l1_provider.rs

@@ -52,6 +52,8 @@ impl L1Provider {
     // Start the provider, get first-scrape events, start L2 sync.
     pub async fn initialize(&mut self, events: Vec<Event>) -> L1ProviderResult<()> {
         info!("Initializing l1 provider");
+        // TODO(guyn): a future PR will replace this check. It will also no longer trigger the
+        // start_l2_sync call.
         if !self.state.is_bootstrapping() {
             // FIXME: This should be return FatalError or similar, which should trigger a planned
             // restart from the infra, since this CAN happen if the scraper recovered from a crash.
@@ -196,6 +198,7 @@ impl L1Provider {
             }
             ProviderState::Bootstrap => Err(L1ProviderError::OutOfSessionGetTransactions),
             ProviderState::Validate => Err(L1ProviderError::GetTransactionConsensusBug),
+            ProviderState::Uninitialized => Err(L1ProviderError::Uninitialized),
         }
     }
 
@@ -225,6 +228,7 @@ impl L1Provider {
                 );
             }
             ProviderState::Bootstrap => Err(L1ProviderError::OutOfSessionValidate),
+            ProviderState::Uninitialized => Err(L1ProviderError::Uninitialized),
         }
     }
 
@@ -544,6 +548,7 @@ impl L1ProviderBuilder {
                 self.config.l1_handler_cancellation_timelock_seconds,
                 self.config.l1_handler_consumption_timelock_seconds,
             ),
+            // TODO(guyn): in a future PR, this will be replaced with ProviderState::Uninitialized.
             state: ProviderState::Bootstrap,
             config: self.config,
             clock: self.clock.unwrap_or_else(|| Arc::new(DefaultClock)),

crates/apollo_l1_provider/src/lib.rs

@@ -26,33 +26,39 @@ use crate::transaction_manager::TransactionManagerConfig;
 /// Current state of the provider, where pending means: idle, between proposal/validation cycles.
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ProviderState {
-    /// Provider is not read for proposing or validating. Use start_block to transition to Propose
+    /// Provider has not been initialized yet, needs to do bootstrapping at least once.
+    Uninitialized,
+    // TODO(guyn): in a upcoming PR, bootstrap will be available not only on startup.
+    /// Provider is catching up using sync. Only happens on startup.
+    Bootstrap,
+    /// Provider is not ready for proposing or validating. Use start_block to transition to Propose
     /// or Validate.
     Pending,
-    /// Provider is ready for proposing. Use commit_block to finish and return to Pending.
+    /// Provider is ready for proposing. Use get_txs to get what you need for a new proposal. Use
+    /// commit_block to finish and return to Pending.
     Propose,
-    /// Provider is catching up using sync. Only happens on startup.
-    Bootstrap,
-    /// Provider is ready for validating. Use validate to validate a transaction.
+    /// Provider is ready for validating. Use validate to validate a transaction. Use commit_block
+    /// to finish and return to Pending.
     Validate,
 }
 
 impl ProviderState {
     pub fn as_str(&self) -> &str {
         match self {
+            ProviderState::Uninitialized => "Uninitialized",
             ProviderState::Pending => "Pending",
             ProviderState::Propose => "Propose",
             ProviderState::Bootstrap => "Bootstrap",
             ProviderState::Validate => "Validate",
         }
     }
 
-    pub fn is_bootstrapping(&self) -> bool {
-        if let ProviderState::Bootstrap = self {
-            return true;
-        }
+    pub fn uninitialized(&self) -> bool {
+        matches!(self, ProviderState::Uninitialized)
+    }
 
-        false
+    pub fn is_bootstrapping(&self) -> bool {
+        matches!(self, ProviderState::Bootstrap)
     }
 
     fn transition_to_pending(&self) -> ProviderState {