Dedicated library for intending and evaluating cosigns

Not only cleans the existing cosign code but enables non-Serai-coordinators to
evaluate cosigns if they gain access to a feed of them (such as over an RPC).
This would let centralized services not only track the finalized chain yet the
cosigned chain without directly running a coordinator.

Still being wrapped up.

coordinator/cosign/src/intend.rs

@@ -0,0 +1,116 @@
+use core::future::Future;
+
+use serai_client::{SeraiError, Serai, validator_sets::primitives::ValidatorSet};
+
+use serai_db::*;
+use serai_task::ContinuallyRan;
+
+use crate::*;
+
+create_db!(
+  CosignIntend {
+    ScanCosignFrom: () -> u64,
+  }
+);
+
+db_channel! {
+  CosignIntendChannels {
+    BlockHasEvents: () -> (u64, HasEvents),
+    IntendedCosigns: (set: ValidatorSet) -> CosignIntent,
+  }
+}
+
+async fn block_has_events_justifying_a_cosign(
+  serai: &Serai,
+  block: u64,
+) -> Result<HasEvents, SeraiError> {
+  let serai = serai.as_of(
+    serai
+      .finalized_block_by_number(block)
+      .await?
+      .expect("couldn't get block which should've been finalized")
+      .hash(),
+  );
+
+  if !serai.validator_sets().key_gen_events().await?.is_empty() {
+    return Ok(HasEvents::Notable);
+  }
+
+  if !serai.coins().burn_with_instruction_events().await?.is_empty() {
+    return Ok(HasEvents::NonNotable);
+  }
+
+  Ok(HasEvents::No)
+}
+
+/// A task to determine which blocks we should intend to cosign.
+pub(crate) struct CosignIntendTask<D: Db> {
+  pub(crate) db: D,
+  pub(crate) serai: Serai,
+}
+
+impl<D: Db> ContinuallyRan for CosignIntendTask<D> {
+  fn run_iteration(&mut self) -> impl Send + Future<Output = Result<bool, String>> {
+    async move {
+      let start_block_number = ScanCosignFrom::get(&self.db).unwrap_or(1);
+      let latest_block_number =
+        self.serai.latest_finalized_block().await.map_err(|e| format!("{e:?}"))?.number();
+
+      for block_number in start_block_number ..= latest_block_number {
+        let mut txn = self.db.txn();
+
+        let mut has_events = block_has_events_justifying_a_cosign(&self.serai, block_number)
+          .await
+          .map_err(|e| format!("{e:?}"))?;
+
+        match has_events {
+          HasEvents::Notable | HasEvents::NonNotable => {
+            let (block, sets) = cosigning_sets_for_block(&self.serai, block_number).await?;
+
+            // If this is notable, it creates a new global session, which we index into the
+            // database now
+            if has_events == HasEvents::Notable {
+              let sets = cosigning_sets(&self.serai.as_of(block.hash())).await?;
+              GlobalSessions::set(
+                &mut txn,
+                GlobalSession::new(sets).id(),
+                &(block.number(), block.hash()),
+              );
+            }
+
+            // If this block doesn't have any cosigners, meaning it'll never be cosigned, we flag it
+            // as not having any events requiring cosigning so we don't attempt to sign/require a
+            // cosign for it
+            if sets.is_empty() {
+              has_events = HasEvents::No;
+            } else {
+              let global_session = GlobalSession::new(sets.clone()).id();
+              // Tell each set of their expectation to cosign this block
+              for set in sets {
+                log::debug!("{:?} will be cosigning block #{block_number}", set);
+                IntendedCosigns::send(
+                  &mut txn,
+                  set,
+                  &CosignIntent {
+                    global_session,
+                    block_number,
+                    block_hash: block.hash(),
+                    notable: has_events == HasEvents::Notable,
+                  },
+                );
+              }
+            }
+          }
+          HasEvents::No => {}
+        }
+        // Populate a singular feed with every block's status for the evluator to work off of
+        BlockHasEvents::send(&mut txn, &(block_number, has_events));
+        // Mark this block as handled, meaning we should scan from the next block moving on
+        ScanCosignFrom::set(&mut txn, &(block_number + 1));
+        txn.commit();
+      }
+
+      Ok(start_block_number <= latest_block_number)
+    }
+  }
+}