Chain agnostic dolos core

crates/cardano/src/eras.rs

@@ -187,7 +187,9 @@ impl ChainSummary {
     }
 }
 
-pub fn load_era_summary<D: Domain>(state: &D::State) -> Result<ChainSummary, ChainError> {
+pub fn load_era_summary<D: Domain>(
+    state: &D::State,
+) -> Result<ChainSummary, ChainError<D::ChainSpecificError>> {
     let eras = state.iter_entities_typed(EraSummary::NS, None)?;
 
     let mut chain = ChainSummary::default();
@@ -201,7 +203,9 @@ pub fn load_era_summary<D: Domain>(state: &D::State) -> Result<ChainSummary, Cha
     Ok(chain)
 }
 
-pub fn load_chain_summary_from_state(state: &impl StateStore) -> Result<ChainSummary, ChainError> {
+pub fn load_chain_summary_from_state(
+    state: &impl StateStore,
+) -> Result<ChainSummary, ChainError<crate::CardanoError>> {
     let eras = state.iter_entities_typed(EraSummary::NS, None)?;
 
     let mut chain = ChainSummary::default();
@@ -237,9 +241,9 @@ pub fn log_epoch_range_to_key_range(
     (start_slot, end_slot, range)
 }
 
-pub fn load_active_era<D: Domain>(
+pub fn load_active_era<D: Domain<ChainSpecificError = crate::CardanoError>>(
     state: &D::State,
-) -> Result<(EraProtocol, EraSummary), ChainError> {
+) -> Result<(EraProtocol, EraSummary), ChainError<crate::CardanoError>> {
     let eras = state.iter_entities_typed::<EraSummary>(EraSummary::NS, None)?;
 
     match eras.last() {
@@ -248,8 +252,8 @@ pub fn load_active_era<D: Domain>(
                 let protocol = EraProtocol::from(key);
                 Ok((protocol, summary))
             }
-            Err(_) => Err(ChainError::EraNotFound),
+            Err(_) => Err(ChainError::ChainSpecific(crate::CardanoError::EraNotFound)),
         },
-        None => Err(ChainError::EraNotFound),
+        None => Err(ChainError::ChainSpecific(crate::CardanoError::EraNotFound)),
     }
 }

crates/cardano/src/estart/commit.rs

@@ -5,9 +5,11 @@
 //! in memory.
 
 use dolos_core::{
-    ArchiveStore, ArchiveWriter, BlockSlot, BrokenInvariant, ChainError, ChainPoint, Domain,
-    Entity, EntityDelta as _, EntityKey, LogKey, NsKey, StateStore, StateWriter, TemporalKey,
+    ArchiveStore, ArchiveWriter, BlockSlot, BrokenInvariant, ChainError, ChainPoint, Entity,
+    EntityDelta as _, EntityKey, LogKey, NsKey, StateStore, StateWriter, TemporalKey,
 };
+
+use crate::CardanoDomain;
 use tracing::{debug, instrument, trace, warn};
 
 use crate::{
@@ -31,7 +33,7 @@ impl super::WorkContext {
     fn collect_era_transition(
         &self,
         state: &impl StateStore,
-    ) -> Result<Option<EraTransitionData>, ChainError> {
+    ) -> Result<Option<EraTransitionData>, ChainError<crate::CardanoError>> {
         let Some(transition) = self.ended_state().pparams.era_transition() else {
             return Ok(None);
         };
@@ -75,9 +77,9 @@ impl super::WorkContext {
         &mut self,
         state: &D::State,
         writer: &<D::State as StateStore>::Writer,
-    ) -> Result<(), ChainError>
+    ) -> Result<(), ChainError<crate::CardanoError>>
     where
-        D: Domain,
+        D: CardanoDomain,
         E: Entity + FixedNamespace + Into<CardanoEntity>,
     {
         let records = state.iter_entities_typed::<E>(E::NS, None)?;
@@ -109,12 +111,12 @@ impl super::WorkContext {
     }
 
     #[instrument(skip_all)]
-    pub fn commit<D: Domain>(
+    pub fn commit<D: CardanoDomain>(
         &mut self,
         state: &D::State,
         archive: &D::Archive,
         slot: BlockSlot,
-    ) -> Result<(), ChainError> {
+    ) -> Result<(), ChainError<crate::CardanoError>> {
         debug!("committing estart changes");
 
         // Collect era transition data first (only 1-2 entities, not a memory concern)

crates/cardano/src/estart/loading.rs

@@ -1,14 +1,19 @@
 use std::sync::Arc;
 
-use dolos_core::{ChainError, Domain, Genesis, StateStore, TxoRef};
+use dolos_core::{ChainError, StateStore, TxoRef};
+
+use crate::CardanoDomain;
 
 use crate::{
     estart::BoundaryVisitor, load_era_summary, roll::WorkDeltas, AccountState, DRepState,
     EraProtocol, FixedNamespace as _, PoolState, ProposalState,
 };
 
 impl super::WorkContext {
-    pub fn compute_deltas<D: Domain>(&mut self, state: &D::State) -> Result<(), ChainError> {
+    pub fn compute_deltas<D: CardanoDomain>(
+        &mut self,
+        state: &D::State,
+    ) -> Result<(), ChainError<crate::CardanoError>> {
         let mut visitor_nonces = super::nonces::BoundaryVisitor;
         let mut visitor_reset = super::reset::BoundaryVisitor::default();
 
@@ -57,38 +62,38 @@ impl super::WorkContext {
     /// Compute the value of unredeemed AVVM UTxOs at the Shelley→Allegra
     /// boundary. These UTxOs are removed from the UTxO set and their value
     /// returned to reserves, matching the Haskell ledger's `translateEra`.
-    fn compute_avvm_reclamation<D: Domain>(
+    fn compute_avvm_reclamation<D: CardanoDomain>(
         state: &D::State,
-        genesis: &Genesis,
-    ) -> Result<u64, ChainError> {
+        genesis: &crate::CardanoGenesis,
+    ) -> Result<u64, ChainError<crate::CardanoError>> {
         let avvm_utxos = pallas::ledger::configs::byron::genesis_avvm_utxos(&genesis.byron);
 
         // Collect all Byron genesis AVVM UTxO refs (bootstrap redeemer addresses)
-        let refs: Vec<TxoRef> = avvm_utxos.iter().map(|(tx, _, _)| TxoRef(*tx, 0)).collect();
+        let refs: Vec<TxoRef> = avvm_utxos
+            .iter()
+            .map(|(tx, _, _)| TxoRef(crate::pallas_hash_to_core(*tx), 0))
+            .collect();
 
         // Query the UTxO set to find which are still unspent
         let remaining = state.get_utxos(refs)?;
 
         // Sum the remaining values
-        let total: u64 = remaining
-            .values()
-            .map(|utxo| {
-                pallas::ledger::traverse::MultiEraOutput::try_from(utxo.as_ref())
-                    .map(|o| o.value().coin())
-                    .unwrap_or(0)
-            })
-            .sum();
-
-        tracing::debug!(
-            remaining_count = remaining.len(),
-            total_avvm = total,
-            "AVVM reclamation at Shelley→Allegra boundary"
-        );
+        let mut total = 0u64;
+
+        for utxo in remaining.values() {
+            total += crate::multi_era_output_from_era_cbor(utxo.as_ref())
+                .map_err(ChainError::ChainSpecific)?
+                .value()
+                .coin();
+        }
 
         Ok(total)
     }
 
-    pub fn load<D: Domain>(state: &D::State, genesis: Arc<Genesis>) -> Result<Self, ChainError> {
+    pub fn load<D: CardanoDomain>(
+        state: &D::State,
+        genesis: Arc<crate::CardanoGenesis>,
+    ) -> Result<Self, ChainError<crate::CardanoError>> {
         let ended_state = crate::load_epoch::<D>(state)?;
         let chain_summary = load_era_summary::<D>(state)?;
         let active_protocol = EraProtocol::from(chain_summary.edge().protocol);

crates/cardano/src/estart/mod.rs

@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use dolos_core::{ChainError, EntityKey, Genesis};
+use dolos_core::{ChainError, EntityKey};
 
 use crate::{
     eras::ChainSummary, roll::WorkDeltas, AccountState, CardanoDelta, CardanoEntity, DRepState,
@@ -24,7 +24,7 @@ pub trait BoundaryVisitor {
         ctx: &mut WorkContext,
         id: &PoolId,
         pool: &PoolState,
-    ) -> Result<(), ChainError> {
+    ) -> Result<(), ChainError<crate::CardanoError>> {
         Ok(())
     }
 
@@ -34,7 +34,7 @@ pub trait BoundaryVisitor {
         ctx: &mut WorkContext,
         id: &AccountId,
         account: &AccountState,
-    ) -> Result<(), ChainError> {
+    ) -> Result<(), ChainError<crate::CardanoError>> {
         Ok(())
     }
 
@@ -44,7 +44,7 @@ pub trait BoundaryVisitor {
         ctx: &mut WorkContext,
         id: &DRepId,
         drep: &DRepState,
-    ) -> Result<(), ChainError> {
+    ) -> Result<(), ChainError<crate::CardanoError>> {
         Ok(())
     }
 
@@ -54,12 +54,12 @@ pub trait BoundaryVisitor {
         ctx: &mut WorkContext,
         id: &ProposalId,
         proposal: &ProposalState,
-    ) -> Result<(), ChainError> {
+    ) -> Result<(), ChainError<crate::CardanoError>> {
         Ok(())
     }
 
     #[allow(unused_variables)]
-    fn flush(&mut self, ctx: &mut WorkContext) -> Result<(), ChainError> {
+    fn flush(&mut self, ctx: &mut WorkContext) -> Result<(), ChainError<crate::CardanoError>> {
         Ok(())
     }
 }
@@ -75,7 +75,7 @@ pub struct WorkContext {
 
     pub active_protocol: EraProtocol,
     pub chain_summary: ChainSummary,
-    pub genesis: Arc<Genesis>,
+    pub genesis: Arc<crate::CardanoGenesis>,
 
     /// Unredeemed AVVM UTxOs reclaimed at the Shelley→Allegra boundary.
     pub avvm_reclamation: u64,

crates/cardano/src/estart/nonces.rs

@@ -34,11 +34,13 @@ impl EntityDelta for NonceTransition {
     }
 }
 
-fn next_largest_stable_slot(ctx: &super::WorkContext) -> BlockSlot {
-    let stability_window = nonce_stability_window(ctx.active_protocol.into(), &ctx.genesis);
+fn next_largest_stable_slot(
+    ctx: &super::WorkContext,
+) -> Result<BlockSlot, ChainError<crate::CardanoError>> {
+    let stability_window = nonce_stability_window(ctx.active_protocol.into(), &ctx.genesis)?;
     let epoch_finish_slot = ctx.chain_summary.epoch_start(ctx.starting_epoch_no() + 1);
 
-    sub!(epoch_finish_slot, stability_window)
+    Ok(sub!(epoch_finish_slot, stability_window))
 }
 
 fn initial_nonces(ctx: &super::WorkContext) -> Option<Nonces> {
@@ -65,8 +67,11 @@ fn next_nonce(ctx: &super::WorkContext) -> Option<Nonces> {
 pub struct BoundaryVisitor;
 
 impl super::BoundaryVisitor for BoundaryVisitor {
-    fn flush(&mut self, ctx: &mut super::WorkContext) -> Result<(), ChainError> {
-        let next_slot = next_largest_stable_slot(ctx);
+    fn flush(
+        &mut self,
+        ctx: &mut super::WorkContext,
+    ) -> Result<(), ChainError<crate::CardanoError>> {
+        let next_slot = next_largest_stable_slot(ctx)?;
         let next_nonce = next_nonce(ctx);
 
         ctx.deltas.add_for_entity(NonceTransition {

crates/cardano/src/estart/reset.rs

@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use dolos_core::{ChainError, Genesis, NsKey};
+use dolos_core::{ChainError, NsKey};
 use pallas::ledger::primitives::Epoch;
 use serde::{Deserialize, Serialize};
 
@@ -87,7 +87,7 @@ pub struct EpochTransition {
     era_transition: Option<EraTransition>,
 
     #[serde(skip)]
-    genesis: Option<Arc<Genesis>>,
+    genesis: Option<Arc<crate::CardanoGenesis>>,
 }
 
 impl std::fmt::Debug for EpochTransition {
@@ -252,7 +252,7 @@ impl super::BoundaryVisitor for BoundaryVisitor {
         ctx: &mut super::WorkContext,
         id: &AccountId,
         _: &AccountState,
-    ) -> Result<(), ChainError> {
+    ) -> Result<(), ChainError<crate::CardanoError>> {
         self.change(AccountTransition::new(id.clone(), ctx.starting_epoch_no()));
 
         Ok(())
@@ -263,13 +263,13 @@ impl super::BoundaryVisitor for BoundaryVisitor {
         ctx: &mut super::WorkContext,
         id: &PoolId,
         _: &PoolState,
-    ) -> Result<(), ChainError> {
+    ) -> Result<(), ChainError<crate::CardanoError>> {
         self.change(PoolTransition::new(id.clone(), ctx.starting_epoch_no()));
 
         Ok(())
     }
 
-    fn flush(&mut self, ctx: &mut WorkContext) -> Result<(), ChainError> {
+    fn flush(&mut self, ctx: &mut WorkContext) -> Result<(), ChainError<crate::CardanoError>> {
         for delta in self.deltas.drain(..) {
             ctx.add_delta(delta);
         }