Merge pull request #1623 from input-output-hk/jpraynaud/1589-chain-observer-chain-point

Chain observer retrieves the current Chain Point

Author: jpraynaud

CHANGELOG.md

@@ -15,6 +15,8 @@ As a minor extension, we have adopted a slightly different versioning convention
 
 - Support incremental import for Cardano Transactions instead of scanning the whole immutable database for every signing round.
 
+- Chain observers support the retrieval of the current Cardano chain point.
+
 - Crates versions:
 
 |  Crate  |  Version  |

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "mithril-aggregator"
-version = "0.4.54"
+version = "0.4.55"
 description = "A Mithril Aggregator server"
 authors = { workspace = true }
 edition = { workspace = true }

mithril-aggregator/Cargo.toml

@@ -1,7 +1,7 @@
 use async_trait::async_trait;
 use mithril_common::chain_observer::{ChainAddress, ChainObserver, ChainObserverError, TxDatum};
 use mithril_common::crypto_helper::{KESPeriod, OpCert};
-use mithril_common::entities::{Epoch, StakeDistribution};
+use mithril_common::entities::{ChainPoint, Epoch, StakeDistribution};
 use mockall::mock;
 
 mock! {
@@ -16,6 +16,8 @@ mock! {
 
         async fn get_current_epoch(&self) -> Result<Option<Epoch>, ChainObserverError>;
 
+        async fn get_current_chain_point(&self) -> Result<Option<ChainPoint>, ChainObserverError>;
+
         async fn get_current_stake_distribution(
             &self,
         ) -> Result<Option<StakeDistribution>, ChainObserverError>;

mithril-aggregator/src/tools/mocks.rs

@@ -1,6 +1,6 @@
 [package]
 name = "mithril-common"
-version = "0.3.28"
+version = "0.3.29"
 description = "Common types, interfaces, and utilities for Mithril nodes."
 authors = { workspace = true }
 edition = { workspace = true }

mithril-common/Cargo.toml

@@ -12,7 +12,7 @@ use tokio::process::Command;
 use crate::chain_observer::interface::{ChainObserver, ChainObserverError};
 use crate::chain_observer::{ChainAddress, TxDatum};
 use crate::crypto_helper::{encode_bech32, KESPeriod, OpCert, SerDeShelleyFileFormat};
-use crate::entities::{Epoch, StakeDistribution};
+use crate::entities::{ChainPoint, Epoch, StakeDistribution};
 use crate::{CardanoNetwork, StdResult};
 
 /// `CliRunner` trait defines the asynchronous methods
@@ -29,6 +29,8 @@ pub trait CliRunner {
     async fn launch_stake_snapshot_all_pools(&self) -> StdResult<String>;
     /// Launches the epoch info.
     async fn launch_epoch(&self) -> StdResult<String>;
+    /// Launches the chain point.
+    async fn launch_chain_point(&self) -> StdResult<String>;
     /// Launches the kes period.
     async fn launch_kes_period(&self, opcert_file: &str) -> StdResult<String>;
 }
@@ -114,6 +116,14 @@ impl CardanoCliRunner {
         command
     }
 
+    fn command_for_chain_point(&self) -> Command {
+        let mut command = self.get_command();
+        command.arg("query").arg("tip");
+        self.post_config_command(&mut command);
+
+        command
+    }
+
     fn command_for_kes_period(&self, opcert_file: &str) -> Command {
         let mut command = self.get_command();
         command
@@ -240,6 +250,22 @@ impl CliRunner for CardanoCliRunner {
         }
     }
 
+    async fn launch_chain_point(&self) -> StdResult<String> {
+        let output = self.command_for_chain_point().output().await?;
+
+        if output.status.success() {
+            Ok(std::str::from_utf8(&output.stdout)?.trim().to_string())
+        } else {
+            let message = String::from_utf8_lossy(&output.stderr);
+
+            Err(anyhow!(
+                "Error launching command {:?}, error = '{}'",
+                self.command_for_chain_point(),
+                message
+            ))
+        }
+    }
+
     async fn launch_kes_period(&self, opcert_file: &str) -> StdResult<String> {
         let output = self.command_for_kes_period(opcert_file).output().await?;
 
@@ -407,6 +433,27 @@ impl ChainObserver for CardanoCliChainObserver {
         }
     }
 
+    async fn get_current_chain_point(&self) -> Result<Option<ChainPoint>, ChainObserverError> {
+        let output = self
+            .cli_runner
+            .launch_chain_point()
+            .await
+            .map_err(ChainObserverError::General)?;
+        let v: Value = serde_json::from_str(&output)
+            .with_context(|| format!("output was = '{output}'"))
+            .map_err(ChainObserverError::InvalidContent)?;
+
+        if let Value::String(hash) = &v["hash"] {
+            Ok(Some(ChainPoint {
+                slot_number: v["slot"].as_u64().unwrap_or_default(),
+                block_number: v["block"].as_u64().unwrap_or_default(),
+                block_hash: hash.to_string(),
+            }))
+        } else {
+            Ok(None)
+        }
+    }
+
     async fn get_current_datums(
         &self,
         address: &ChainAddress,
@@ -485,6 +532,22 @@ mod tests {
         assert_eq!(Epoch(120), epoch);
     }
 
+    #[tokio::test]
+    async fn test_get_current_chain_point() {
+        let observer = CardanoCliChainObserver::new(Box::<TestCliRunner>::default());
+        let chain_point = observer.get_current_chain_point().await.unwrap().unwrap();
+
+        assert_eq!(
+            ChainPoint {
+                slot_number: 25886617,
+                block_number: 1270276,
+                block_hash: "7383b17d7b05b0953cf0649abff60173995eb9febe556889333e20e1e5b7ca84"
+                    .to_string(),
+            },
+            chain_point
+        );
+    }
+
     #[tokio::test]
     async fn test_cli_testnet_runner() {
         let runner = CardanoCliRunner::new(

mithril-common/src/chain_observer/cli_observer.rs

@@ -18,6 +18,9 @@ pub struct FakeObserver {
     /// [get_current_epoch]: ChainObserver::get_current_epoch
     pub current_time_point: RwLock<Option<TimePoint>>,
 
+    /// The current chain point
+    pub current_chain_point: RwLock<Option<ChainPoint>>,
+
     /// A list of [TxDatum], used by [get_current_datums]
     ///
     /// [get_current_datums]: ChainObserver::get_current_datums
@@ -30,6 +33,7 @@ impl FakeObserver {
         Self {
             signers: RwLock::new(vec![]),
             current_time_point: RwLock::new(current_time_point),
+            current_chain_point: RwLock::new(None),
             datums: RwLock::new(vec![]),
         }
     }
@@ -52,6 +56,13 @@ impl FakeObserver {
         *signers = new_signers;
     }
 
+    /// Set the chain point that will use to compute the result of
+    /// [get_current_chain_point][ChainObserver::get_current_chain_point].
+    pub async fn set_current_chain_point(&self, new_current_chain_point: Option<ChainPoint>) {
+        let mut current_chain_point = self.current_chain_point.write().await;
+        *current_chain_point = new_current_chain_point;
+    }
+
     /// Set the datums that will use to compute the result of
     /// [get_current_datums][ChainObserver::get_current_datums].
     pub async fn set_datums(&self, new_datums: Vec<TxDatum>) {
@@ -88,6 +99,10 @@ impl ChainObserver for FakeObserver {
             .map(|time_point| time_point.epoch))
     }
 
+    async fn get_current_chain_point(&self) -> Result<Option<ChainPoint>, ChainObserverError> {
+        Ok(self.current_chain_point.read().await.clone())
+    }
+
     async fn get_current_stake_distribution(
         &self,
     ) -> Result<Option<StakeDistribution>, ChainObserverError> {
@@ -124,6 +139,21 @@ mod tests {
         assert_eq!(Some(time_point.epoch), current_epoch);
     }
 
+    #[tokio::test]
+    async fn test_get_current_chain_point() {
+        let fake_observer = FakeObserver::new(None);
+        fake_observer
+            .set_current_chain_point(Some(fake_data::chain_point()))
+            .await;
+        let chain_point = fake_observer.get_current_chain_point().await.unwrap();
+
+        assert_eq!(
+            Some(fake_data::chain_point()),
+            chain_point,
+            "get current chain point should not fail"
+        );
+    }
+
     #[tokio::test]
     async fn test_get_current_stake_distribution() {
         let fake_observer = FakeObserver::new(None);

mithril-common/src/chain_observer/fake_observer.rs

@@ -36,6 +36,9 @@ pub trait ChainObserver: Sync + Send {
     /// Retrieve the current epoch of the Cardano network
     async fn get_current_epoch(&self) -> Result<Option<Epoch>, ChainObserverError>;
 
+    /// Retrieve the current chain point of the Cardano network
+    async fn get_current_chain_point(&self) -> Result<Option<ChainPoint>, ChainObserverError>;
+
     /// Retrieve the current stake distribution of the Cardano network
     async fn get_current_stake_distribution(
         &self,

mithril-common/src/chain_observer/interface.rs

@@ -25,7 +25,7 @@ use std::{
 use crate::{
     chain_observer::{interface::*, ChainAddress, TxDatum},
     crypto_helper::{encode_bech32, KESPeriod, OpCert},
-    entities::{Epoch, StakeDistribution},
+    entities::{ChainPoint, Epoch, StakeDistribution},
     CardanoNetwork, StdResult,
 };
 
@@ -384,6 +384,11 @@ impl ChainObserver for PallasChainObserver {
         Ok(Some(Epoch(epoch as u64)))
     }
 
+    async fn get_current_chain_point(&self) -> Result<Option<ChainPoint>, ChainObserverError> {
+        // TODO: Implement get_current_chain_point with pallas
+        todo!("Implement get_current_chain_point")
+    }
+
     async fn get_current_datums(
         &self,
         address: &ChainAddress,

mithril-common/src/chain_observer/pallas_observer.rs

@@ -169,6 +169,23 @@ pool1qz2vzszautc2c8mljnqre2857dpmheq7kgt6vav0s38tvvhxm6w   1.051e-6
         Ok(output.to_string())
     }
 
+    /// launches the chain point info.
+    async fn launch_chain_point(&self) -> StdResult<String> {
+        let output = r#"
+{
+    "block": 1270276,
+    "epoch": 299,
+    "era": "Conway",
+    "hash": "7383b17d7b05b0953cf0649abff60173995eb9febe556889333e20e1e5b7ca84",
+    "slot": 25886617,
+    "slotInEpoch": 53017,
+    "slotsToEpochEnd": 33383,
+    "syncProgress": "100.00"
+}"#;
+
+        Ok(output.to_string())
+    }
+
     /// launches the kes period.
     async fn launch_kes_period(&self, _opcert_file: &str) -> StdResult<String> {
         let output = r#"