fix: use option

Author: prestwich

src/tasks/env.rs

@@ -45,7 +45,7 @@ impl EnvTask {
     }
 
     /// Construct the BlockEnv and send it to the sender.
-    pub async fn task_fut(self, sender: watch::Sender<BlockEnv>) {
+    pub async fn task_fut(self, sender: watch::Sender<Option<BlockEnv>>) {
         let span = info_span!("EnvTask::task_fut::init");
         let mut poller = match self.provider.watch_blocks().instrument(span.clone()).await {
             Ok(poller) => poller,
@@ -64,7 +64,10 @@ impl EnvTask {
             blocks.next().instrument(info_span!("EnvTask::task_fut::stream")).await
         {
             let Some(block) = blocks.last() else {
+                // Clear the env, as the block has changed but we can't
+                // get a new one
                 debug!("empty filter changes");
+                let _ = sender.send(None);
                 continue;
             };
             let span = info_span!("EnvTask::task_fut::loop", hash = %block, number = tracing::field::Empty);
@@ -79,11 +82,13 @@ impl EnvTask {
                 Ok(Some(block)) => block.header.inner,
                 Ok(None) => {
                     let _span = span.enter();
+                    let _ = sender.send(None);
                     debug!("block not found");
                     continue;
                 }
                 Err(err) => {
                     let _span = span.enter();
+                    let _ = sender.send(None);
                     error!(%err, "Failed to get latest block");
                     break;
                 }
@@ -92,16 +97,16 @@ impl EnvTask {
 
             let env = self.construct_block_env(&previous);
             debug!(?env, "constructed block env");
-            if let Err(_) = sender.send(env) {
+            if let Err(_) = sender.send(Some(env)) {
                 // The receiver has been dropped, so we can stop the task.
                 break;
             }
         }
     }
 
     /// Spawn the task and return a watch::Receiver for the BlockEnv.
-    pub fn spawn(self) -> watch::Receiver<BlockEnv> {
-        let (sender, receiver) = watch::channel(BlockEnv::default());
+    pub fn spawn(self) -> watch::Receiver<Option<BlockEnv>> {
+        let (sender, receiver) = watch::channel(None);
         let fut = self.task_fut(sender);
         tokio::spawn(fut);