Remove historical state access from Serai

Resolves https://github.com/serai-dex/serai/issues/694.

coordinator/substrate/src/canonical.rs

@@ -73,21 +73,13 @@ impl<D: Db> ContinuallyRan for CanonicalEventStream<D> {
               }
               Err(serai_cosign::Faulted) => return Err("cosigning process faulted".to_string()),
             };
-            let temporal_serai = serai.as_of(block_hash).await.map_err(|e| format!("{e}"))?;
-            let temporal_serai_validators = temporal_serai.validator_sets();
-            let temporal_serai_instructions = temporal_serai.in_instructions();
-            let temporal_serai_coins = temporal_serai.coins();
-
-            let (block, set_keys_events, slash_report_events, batch_events, burn_events) =
-              tokio::try_join!(
-                serai.block(block_hash),
-                temporal_serai_validators.set_keys_events(),
-                temporal_serai_validators.slash_report_events(),
-                temporal_serai_instructions.batch_events(),
-                temporal_serai_coins.burn_with_instruction_events(),
-              )
-              .map_err(|e| format!("{e:?}"))?;
-            let Some(block) = block else {
+            let events = serai.events(block_hash).await.map_err(|e| format!("{e}"))?;
+            let set_keys_events = events.validator_sets().set_keys_events().cloned().collect();
+            let slash_report_events =
+              events.validator_sets().slash_report_events().cloned().collect();
+            let batch_events = events.in_instructions().batch_events().cloned().collect();
+            let burn_events = events.coins().burn_with_instruction_events().cloned().collect();
+            let Some(block) = serai.block(block_hash).await.map_err(|e| format!("{e:?}"))? else {
               Err(format!("Serai node didn't have cosigned block #{block_number}"))?
             };
 

coordinator/substrate/src/ephemeral.rs

@@ -6,7 +6,7 @@ use futures::stream::{StreamExt, FuturesOrdered};
 use serai_client_serai::{
   abi::primitives::{
     BlockHash,
-    crypto::EmbeddedEllipticCurveKeys,
+    crypto::EmbeddedEllipticCurveKeys as EmbeddedEllipticCurveKeysStruct,
     network_id::ExternalNetworkId,
     validator_sets::{KeyShares, ExternalValidatorSet},
     address::SeraiAddress,
@@ -24,6 +24,10 @@ use crate::NewSetInformation;
 create_db!(
   CoordinatorSubstrateEphemeral {
     NextBlock: () -> u64,
+    EmbeddedEllipticCurveKeys: (
+      network: ExternalNetworkId,
+      validator: SeraiAddress
+    ) -> EmbeddedEllipticCurveKeysStruct,
   }
 );
 
@@ -56,6 +60,7 @@ impl<D: Db> ContinuallyRan for EphemeralEventStream<D> {
       struct EphemeralEvents {
         block_hash: BlockHash,
         time: u64,
+        embedded_elliptic_curve_keys_events: Vec<serai_client_serai::abi::validator_sets::Event>,
         set_decided_events: Vec<serai_client_serai::abi::validator_sets::Event>,
         accepted_handover_events: Vec<serai_client_serai::abi::validator_sets::Event>,
       }
@@ -76,15 +81,17 @@ impl<D: Db> ContinuallyRan for EphemeralEventStream<D> {
               Err(serai_cosign::Faulted) => return Err("cosigning process faulted".to_string()),
             };
 
-            let temporal_serai = serai.as_of(block_hash).await.map_err(|e| format!("{e}"))?;
-            let temporal_serai_validators = temporal_serai.validator_sets();
-            let (block, set_decided_events, accepted_handover_events) = tokio::try_join!(
-              serai.block(block_hash),
-              temporal_serai_validators.set_decided_events(),
-              temporal_serai_validators.accepted_handover_events(),
-            )
-            .map_err(|e| format!("{e:?}"))?;
-            let Some(block) = block else {
+            let events = serai.events(block_hash).await.map_err(|e| format!("{e}"))?;
+            let embedded_elliptic_curve_keys_events = events
+              .validator_sets()
+              .set_embedded_elliptic_curve_keys_events()
+              .cloned()
+              .collect::<Vec<_>>();
+            let set_decided_events =
+              events.validator_sets().set_decided_events().cloned().collect::<Vec<_>>();
+            let accepted_handover_events =
+              events.validator_sets().accepted_handover_events().cloned().collect::<Vec<_>>();
+            let Some(block) = serai.block(block_hash).await.map_err(|e| format!("{e:?}"))? else {
               Err(format!("Serai node didn't have cosigned block #{block_number}"))?
             };
 
@@ -92,7 +99,13 @@ impl<D: Db> ContinuallyRan for EphemeralEventStream<D> {
             let time = block.header.unix_time_in_millis() / 1000;
             Ok((
               block_number,
-              EphemeralEvents { block_hash, time, set_decided_events, accepted_handover_events },
+              EphemeralEvents {
+                block_hash,
+                time,
+                embedded_elliptic_curve_keys_events,
+                set_decided_events,
+                accepted_handover_events,
+              },
             ))
           }
         }
@@ -123,30 +136,39 @@ impl<D: Db> ContinuallyRan for EphemeralEventStream<D> {
 
         let mut txn = self.db.txn();
 
+        for event in block.embedded_elliptic_curve_keys_events {
+          let serai_client_serai::abi::validator_sets::Event::SetEmbeddedEllipticCurveKeys {
+            validator,
+            keys,
+          } = &event
+          else {
+            panic!(
+              "{}: {event:?}",
+              "`SetEmbeddedEllipticCurveKeys` event wasn't a `SetEmbeddedEllipticCurveKeys` event"
+            );
+          };
+
+          EmbeddedEllipticCurveKeys::set(&mut txn, keys.network(), *validator, keys);
+        }
+
         for set_decided in block.set_decided_events {
           let serai_client_serai::abi::validator_sets::Event::SetDecided { set, validators } =
             &set_decided
           else {
             panic!("`SetDecided` event wasn't a `SetDecided` event: {set_decided:?}");
           };
+
           // We only coordinate over external networks
           let Ok(set) = ExternalValidatorSet::try_from(*set) else { continue };
-
-          let serai = self.serai.as_of(block.block_hash).await.map_err(|e| format!("{e}"))?;
-          let serai = serai.validator_sets();
           let validators =
-            validators.iter().map(|(validator, weight)| (*validator, weight)).collect::<Vec<_>>();
+            validators.iter().map(|(validator, weight)| (*validator, weight.0)).collect::<Vec<_>>();
+
           let in_set = validators.iter().any(|(validator, _)| *validator == self.validator);
           if in_set {
             if u16::try_from(validators.len()).is_err() {
               Err("more than u16::MAX validators sent")?;
             }
 
-            let validators = validators
-              .into_iter()
-              .map(|(validator, weight)| (validator, weight.0))
-              .collect::<Vec<_>>();
-
             // Do the summation in u32 so we don't risk a u16 overflow
             let total_weight = validators.iter().map(|(_, weight)| u32::from(*weight)).sum::<u32>();
             if total_weight > u32::from(KeyShares::MAX_PER_SET) {
@@ -159,50 +181,26 @@ impl<D: Db> ContinuallyRan for EphemeralEventStream<D> {
               .expect("value smaller than `u16` constant but doesn't fit in `u16`");
 
             // Fetch all of the validators' embedded elliptic curve keys
-            let mut embedded_elliptic_curve_keys = FuturesOrdered::new();
-            for (validator, _) in &validators {
-              let validator = *validator;
-              // try_join doesn't return a future so we need to wrap it in this additional async
-              // block
-              embedded_elliptic_curve_keys.push_back({
-                let serai = serai.clone();
-                async move {
-                  match serai.embedded_elliptic_curve_keys(validator, set.network).await {
-                    Ok(Some(keys)) => Ok(Some((
-                      validator,
-                      match keys {
-                        EmbeddedEllipticCurveKeys::Bitcoin(substrate, external) => {
-                          assert_eq!(set.network, ExternalNetworkId::Bitcoin);
-                          (substrate, external.as_slice().to_vec())
-                        }
-                        EmbeddedEllipticCurveKeys::Ethereum(substrate, external) => {
-                          assert_eq!(set.network, ExternalNetworkId::Ethereum);
-                          (substrate, external.as_slice().to_vec())
-                        }
-                        EmbeddedEllipticCurveKeys::Monero(substrate) => {
-                          assert_eq!(set.network, ExternalNetworkId::Monero);
-                          (substrate, substrate.as_slice().to_vec())
-                        }
-                      },
-                    ))),
-                    Ok(None) => Ok(None),
-                    Err(e) => Err(e),
-                  }
-                }
-              });
-            }
-
             let mut evrf_public_keys = Vec::with_capacity(usize::from(total_weight));
             for (validator, weight) in &validators {
-              let Some((future_validator, (substrate_embedded_key, external_embedded_key))) =
-                embedded_elliptic_curve_keys.next().await.unwrap().map_err(|e| format!("{e:?}"))?
-              else {
-                Err("`SetDecided` with validator missing an embedded key".to_string())?
+              let keys = match EmbeddedEllipticCurveKeys::get(&txn, set.network, *validator)
+                .expect("selected validator lacked embedded elliptic curve keys")
+              {
+                EmbeddedEllipticCurveKeysStruct::Bitcoin(substrate, external) => {
+                  assert_eq!(set.network, ExternalNetworkId::Bitcoin);
+                  (substrate, external.to_vec())
+                }
+                EmbeddedEllipticCurveKeysStruct::Ethereum(substrate, external) => {
+                  assert_eq!(set.network, ExternalNetworkId::Ethereum);
+                  (substrate, external.to_vec())
+                }
+                EmbeddedEllipticCurveKeysStruct::Monero(substrate) => {
+                  assert_eq!(set.network, ExternalNetworkId::Monero);
+                  (substrate, substrate.to_vec())
+                }
               };
-              assert_eq!(*validator, future_validator);
-
               for _ in 0 .. *weight {
-                evrf_public_keys.push((substrate_embedded_key, external_embedded_key.clone()));
+                evrf_public_keys.push(keys.clone());
               }
             }
 
@@ -213,6 +211,7 @@ impl<D: Db> ContinuallyRan for EphemeralEventStream<D> {
               // TODO: This should be inlined into the Processor's key gen code
               // It's legacy from when we removed participants from the key gen
               threshold: ((total_weight * 2) / 3) + 1,
+              // TODO: Why are `validators` and `evrf_public_keys` two separate fields?
               validators,
               evrf_public_keys,
               participant_indexes: Default::default(),

coordinator/substrate/src/publish_slash_report.rs

@@ -36,8 +36,7 @@ impl<D: Db> PublishSlashReportTask<D> {
 
     // This uses the latest finalized block, not the latest cosigned block, which should be
     // fine as in the worst case, the only impact is no longer attempting TX publication
-    let serai = self.serai.as_of_latest_finalized_block().await.map_err(|e| format!("{e:?}"))?;
-    let serai = serai.validator_sets();
+    let serai = self.serai.state().await.map_err(|e| format!("{e:?}"))?;
     let session_after_slash_report = Session(session.0 + 1);
     let current_session =
       serai.current_session(network.into()).await.map_err(|e| format!("{e:?}"))?;

coordinator/substrate/src/set_keys.rs

@@ -40,9 +40,7 @@ impl<D: Db> ContinuallyRan for SetKeysTask<D> {
 
         // This uses the latest finalized block, not the latest cosigned block, which should be
         // fine as in the worst case, the only impact is no longer attempting TX publication
-        let serai =
-          self.serai.as_of_latest_finalized_block().await.map_err(|e| format!("{e:?}"))?;
-        let serai = serai.validator_sets();
+        let serai = self.serai.state().await.map_err(|e| format!("{e:?}"))?;
         let current_session =
           serai.current_session(network.into()).await.map_err(|e| format!("{e:?}"))?;
         let current_session = current_session.map(|session| session.0);