revert StartingLiveStream->SwitchingToLive

Author: 0xNeshi

src/block_range_scanner/common.rs

@@ -33,7 +33,7 @@ pub(crate) async fn stream_live_blocks<N: Network>(
         return;
     };
 
-    if notify_after_first_block && !sender.try_stream(Notification::StartingLiveStream).await {
+    if notify_after_first_block && !sender.try_stream(Notification::SwitchingToLive).await {
         return;
     }
 

src/block_range_scanner/sync_handler.rs

@@ -197,7 +197,7 @@ impl<N: Network> SyncHandler<N> {
             }
         };
 
-        if !sender.try_stream(Notification::StartingLiveStream).await {
+        if !sender.try_stream(Notification::SwitchingToLive).await {
             return;
         }
 

src/event_scanner/scanner/sync/mod.rs

@@ -16,7 +16,7 @@ impl EventScannerBuilder<Synchronize> {
     ///
     /// 1. **Latest events phase**: Collects up to `count` most recent events by scanning backwards
     ///    from the current chain tip. Events are delivered in chronological order.
-    /// 2. **Automatic transition**: Emits [`Notification::StartingLiveStream`][switch_to_live] to
+    /// 2. **Automatic transition**: Emits [`Notification::SwitchingToLive`][switch_to_live] to
     ///    signal the mode change
     /// 3. **Live streaming phase**: Continuously monitors and streams new events as they arrive
     ///    on-chain
@@ -50,7 +50,7 @@ impl EventScannerBuilder<Synchronize> {
     ///         }
     ///         Ok(Message::Notification(notification)) => {
     ///             println!("Notification received: {:?}", notification);
-    ///             // You'll see Notification::StartingLiveStream when transitioning
+    ///             // You'll see Notification::SwitchingToLive when transitioning
     ///         }
     ///         Err(e) => {
     ///             eprintln!("Error: {}", e);
@@ -101,7 +101,7 @@ impl EventScannerBuilder<Synchronize> {
     /// [subscribe]: crate::EventScanner::subscribe
     /// [start]: crate::event_scanner::EventScanner::start
     /// [reorg]: crate::types::Notification::ReorgDetected
-    /// [switch_to_live]: crate::types::Notification::StartingLiveStream
+    /// [switch_to_live]: crate::types::Notification::SwitchingToLive
     #[must_use]
     pub fn from_latest(self, count: usize) -> EventScannerBuilder<SyncFromLatestEvents> {
         EventScannerBuilder::<SyncFromLatestEvents>::new(count)
@@ -114,7 +114,7 @@ impl EventScannerBuilder<Synchronize> {
     ///
     /// 1. **Historical sync phase**: Streams events from `from_block` up to the current confirmed
     ///    tip
-    /// 2. **Automatic transition**: Emits [`Notification::StartingLiveStream`][switch_to_live] to
+    /// 2. **Automatic transition**: Emits [`Notification::SwitchingToLive`][switch_to_live] to
     ///    signal the mode change
     /// 3. **Live streaming phase**: Continuously monitors and streams new events as they arrive
     ///    on-chain
@@ -148,7 +148,7 @@ impl EventScannerBuilder<Synchronize> {
     ///         }
     ///         Ok(Message::Notification(notification)) => {
     ///             println!("Notification received: {:?}", notification);
-    ///             // You'll see Notification::StartingLiveStream when transitioning
+    ///             // You'll see Notification::SwitchingToLive when transitioning
     ///         }
     ///         Err(e) => {
     ///             eprintln!("Error: {}", e);
@@ -208,7 +208,7 @@ impl EventScannerBuilder<Synchronize> {
     /// [subscribe]: crate::EventScanner::subscribe
     /// [start]: crate::event_scanner::EventScanner::start
     /// [reorg]: crate::types::Notification::ReorgDetected
-    /// [switch_to_live]: crate::types::Notification::StartingLiveStream
+    /// [switch_to_live]: crate::types::Notification::SwitchingToLive
     #[must_use]
     pub fn from_block(self, block_id: impl Into<BlockId>) -> EventScannerBuilder<SyncFromBlock> {
         EventScannerBuilder::<SyncFromBlock>::new(block_id.into())

src/types.rs

@@ -15,7 +15,7 @@ pub enum ScannerMessage<T: Clone> {
 
 #[derive(Copy, Debug, Clone, PartialEq)]
 pub enum Notification {
-    StartingLiveStream,
+    SwitchingToLive,
     ReorgDetected,
 }
 

tests/block_range_scanner.rs

@@ -90,7 +90,7 @@ async fn stream_from_starts_at_latest_once_it_has_enough_confirmations() -> anyh
     let mut stream = assert_empty!(stream);
 
     provider.anvil_mine(Some(1), None).await?;
-    assert_next!(stream, Notification::StartingLiveStream);
+    assert_next!(stream, Notification::SwitchingToLive);
     assert_next!(stream, 20..=20);
     let mut stream = assert_empty!(stream);
 

tests/sync/from_block.rs

@@ -33,7 +33,7 @@ async fn replays_historical_then_switches_to_live() -> anyhow::Result<()> {
     );
 
     // chain tip reached
-    assert_next!(stream, Notification::StartingLiveStream);
+    assert_next!(stream, Notification::SwitchingToLive);
 
     // now emit live events
     contract.increase().send().await?.watch().await?;
@@ -72,9 +72,9 @@ async fn sync_from_future_block_waits_until_minted() -> anyhow::Result<()> {
     // Act: emit an event that will be mined in block == future_start
     contract.increase().send().await?.watch().await?;
 
-    // only after the live event at `future_start_block` is emitted, will `StartingLiveStream` be
+    // only after the live event at `future_start_block` is emitted, will `SwitchingToLive` be
     // streamed
-    assert_next!(stream, Notification::StartingLiveStream);
+    assert_next!(stream, Notification::SwitchingToLive);
     // Assert: the first streamed message arrives and contains the expected event
     assert_next!(stream, &[TestCounter::CountIncreased { newCount: U256::from(3) }]);
     assert_empty!(stream);
@@ -103,7 +103,7 @@ async fn block_confirmations_mitigate_reorgs() -> anyhow::Result<()> {
             TestCounter::CountIncreased { newCount: U256::from(2) }
         ]
     );
-    assert_next!(stream, Notification::StartingLiveStream);
+    assert_next!(stream, Notification::SwitchingToLive);
 
     // emit "live" events
     for _ in 0..2 {

tests/sync/from_latest.rs

@@ -39,10 +39,10 @@ async fn happy_path_no_duplicates() -> anyhow::Result<()> {
     contract.increase().send().await?.watch().await?;
     contract.increase().send().await?.watch().await?;
 
-    // Assert `StartingLiveStream` after emitting live events, because the test finishes the "latest
+    // Assert `SwitchingToLive` after emitting live events, because the test finishes the "latest
     // events" phase before new events are emitted, thus the "live" phase actually starts from a
     // future block.
-    assert_next!(stream, Notification::StartingLiveStream);
+    assert_next!(stream, Notification::SwitchingToLive);
     assert_event_sequence_final!(
         stream,
         &[
@@ -81,10 +81,10 @@ async fn fewer_historical_then_continues_live() -> anyhow::Result<()> {
     contract.increase().send().await?.watch().await?;
     contract.increase().send().await?.watch().await?;
 
-    // Assert `StartingLiveStream` after emitting live events, because the test finishes the "latest
+    // Assert `SwitchingToLive` after emitting live events, because the test finishes the "latest
     // events" phase before new events are emitted, thus the "live" phase actually starts from a
     // future block.
-    assert_next!(stream, Notification::StartingLiveStream);
+    assert_next!(stream, Notification::SwitchingToLive);
     assert_event_sequence_final!(
         stream,
         &[
@@ -128,10 +128,10 @@ async fn exact_historical_count_then_live() -> anyhow::Result<()> {
     // Live continues
     contract.increase().send().await?.watch().await?;
 
-    // Assert `StartingLiveStream` after emitting live events, because the test finishes the "latest
+    // Assert `SwitchingToLive` after emitting live events, because the test finishes the "latest
     // events" phase before new events are emitted, thus the "live" phase actually starts from a
     // future block.
-    assert_next!(stream, Notification::StartingLiveStream);
+    assert_next!(stream, Notification::SwitchingToLive);
     assert_next!(stream, &[TestCounter::CountIncreased { newCount: U256::from(5) }]);
     assert_empty!(stream);
 
@@ -156,10 +156,10 @@ async fn no_historical_only_live_streams() -> anyhow::Result<()> {
 
     // Latest events are empty
 
-    // Assert `StartingLiveStream` after emitting live events, because the test finishes the "latest
+    // Assert `SwitchingToLive` after emitting live events, because the test finishes the "latest
     // events" phase before new events are emitted, thus the "live" phase actually starts from a
     // future block.
-    assert_next!(stream, Notification::StartingLiveStream);
+    assert_next!(stream, Notification::SwitchingToLive);
     assert_event_sequence_final!(
         stream,
         &[
@@ -207,10 +207,10 @@ async fn block_gaps_do_not_affect_number_of_events_streamed() -> anyhow::Result<
     // Immediately produce a new live event in a new block
     contract.increase().send().await?.watch().await?;
 
-    // Assert `StartingLiveStream` after emitting live events, because the test finishes the "latest
+    // Assert `SwitchingToLive` after emitting live events, because the test finishes the "latest
     // events" phase before new events are emitted, thus the "live" phase actually starts from a
     // future block.
-    assert_next!(stream, Notification::StartingLiveStream);
+    assert_next!(stream, Notification::SwitchingToLive);
     assert_next!(stream, &[TestCounter::CountIncreased { newCount: U256::from(4) }]);
     assert_empty!(stream);
 
@@ -242,7 +242,7 @@ async fn waiting_on_live_logs_arriving() -> anyhow::Result<()> {
     );
     assert_empty!(stream);
 
-    // `Notification::StartingLiveStream` arrives only on first live block received
+    // `Notification::SwitchingToLive` arrives only on first live block received
 
     Ok(())
 }