feat(client-wasm): add list/get per epoch/latest/latest(-offset) for cdb and csd

Author: Alenar

mithril-client-wasm/ci-test/index.js

@@ -201,10 +201,35 @@ if (aggregator_capabilities.includes("CardanoStakeDistribution")) {
   await run_test("get_cardano_stake_distribution_by_epoch", test_number, async () => {
     let epoch = BigInt(cardano_stake_distributions[0].epoch);
 
-    cardano_stake_distribution = await client.get_cardano_stake_distribution_by_epoch(epoch);
-    console.log("cardano_stake_distribution by epoch", cardano_stake_distribution);
+    let cardano_stake_distribution_by_epoch =
+      await client.get_cardano_stake_distribution_by_epoch(epoch);
+    console.log("cardano_stake_distribution by epoch", cardano_stake_distribution_by_epoch);
   });
 
+  test_number++;
+  await run_test("get_cardano_stake_distribution_for_latest_epoch", test_number, async () => {
+    let cardano_stake_distribution_for_latest_epoch =
+      await client.get_cardano_stake_distribution_for_latest_epoch();
+    console.log(
+      "cardano_stake_distribution for latest epoch",
+      cardano_stake_distribution_for_latest_epoch,
+    );
+  });
+
+  test_number++;
+  await run_test(
+    "get_cardano_stake_distribution_for_latest_epoch_with_offset",
+    test_number,
+    async () => {
+      let cardano_stake_distribution_for_latest_epoch_with_offset =
+        await client.get_cardano_stake_distribution_for_latest_epoch({ offset: 2 });
+      console.log(
+        "cardano_stake_distribution for latest epoch with offset",
+        cardano_stake_distribution_for_latest_epoch_with_offset,
+      );
+    },
+  );
+
   let certificate;
   test_number++;
   await run_test("get_mithril_certificate", test_number, async () => {
@@ -240,24 +265,52 @@ if (aggregator_capabilities.includes("CardanoStakeDistribution")) {
       valid_cardano_stake_distribution_message,
     );
   });
+}
 
-  if (aggregator_capabilities.includes("CardanoDatabase")) {
-    let cardano_database_snapshots;
-    test_number++;
-    await run_test("list_cardano_database_v2", test_number, async () => {
-      cardano_database_snapshots = await client.list_cardano_database_v2();
-      console.log("cardano_database_snapshots", cardano_database_snapshots);
-    });
+if (aggregator_capabilities.includes("CardanoDatabase")) {
+  let cardano_database_snapshots;
+  test_number++;
+  await run_test("list_cardano_database_v2", test_number, async () => {
+    cardano_database_snapshots = await client.list_cardano_database_v2();
+    console.log("cardano_database_snapshots", cardano_database_snapshots);
+  });
 
-    let cardano_database_snapshot;
-    test_number++;
-    await run_test("get_cardano_database_v2", test_number, async () => {
-      cardano_database_snapshot = await client.get_cardano_database_v2(
-        cardano_database_snapshots[0].hash,
-      );
-      console.log("cardano_database_snapshot", cardano_database_snapshot);
-    });
-  }
+  test_number++;
+  await run_test("list_cardano_database_v2_per_epoch", test_number, async () => {
+    let epoch = BigInt(cardano_database_snapshots[0].beacon.epoch);
+    const cardano_database_snapshots_per_epoch =
+      await client.list_cardano_database_v2_per_epoch(epoch);
+    console.log("cardano_database_snapshots for epoch", cardano_database_snapshots_per_epoch);
+  });
+
+  test_number++;
+  await run_test("list_cardano_database_v2_for_latest_epoch", test_number, async () => {
+    const cardano_database_snapshots_for_latest_epoch =
+      await client.list_cardano_database_v2_for_latest_epoch();
+    console.log(
+      "cardano_database_snapshots for latest epoch",
+      cardano_database_snapshots_for_latest_epoch,
+    );
+  });
+
+  test_number++;
+  await run_test("list_cardano_database_v2_for_latest_epoch_with_offset", test_number, async () => {
+    const cardano_database_snapshots_for_latest_epoch_with_offset =
+      await client.list_cardano_database_v2_for_latest_epoch({ offset: 3 });
+    console.log(
+      "cardano_database_snapshots for latest epoch with offset",
+      cardano_database_snapshots_for_latest_epoch_with_offset,
+    );
+  });
+
+  let cardano_database_snapshot;
+  test_number++;
+  await run_test("get_cardano_database_v2", test_number, async () => {
+    cardano_database_snapshot = await client.get_cardano_database_v2(
+      cardano_database_snapshots[0].hash,
+    );
+    console.log("cardano_database_snapshot", cardano_database_snapshot);
+  });
 }
 
 add_finished_div();

mithril-client-wasm/src/certificate_verification_cache.rs

@@ -40,7 +40,7 @@ impl CachedCertificate {
 impl LocalStorageCertificateVerifierCache {
     /// `LocalStorageCertificateVerifierCache` factory
     pub fn new(cache_key_prefix_seed: &str, expiration_delay: TimeDelta) -> Self {
-        const CACHE_KEY_BASE_PREFIX: &'static str = "certificate_cache";
+        const CACHE_KEY_BASE_PREFIX: &str = "certificate_cache";
 
         LocalStorageCertificateVerifierCache {
             cache_key_prefix: format!("{CACHE_KEY_BASE_PREFIX}_{cache_key_prefix_seed}_"),

mithril-client-wasm/src/client_wasm.rs

@@ -1,6 +1,6 @@
 use async_trait::async_trait;
 use chrono::TimeDelta;
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use std::sync::Arc;
 use wasm_bindgen::prelude::*;
 
@@ -41,6 +41,24 @@ impl FeedbackReceiver for JSBroadcastChannelFeedbackReceiver {
     }
 }
 
+/// Parameters that can be passed as a [JsValue] to methods that fetch data based on the latest epoch
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+struct LatestEpochOptions {
+    pub offset: Option<u64>,
+}
+
+impl LatestEpochOptions {
+    fn parse_from_js_value(js_value: JsValue) -> Result<Self, JsValue> {
+        let options = if js_value.is_object() {
+            serde_wasm_bindgen::from_value(js_value)
+                .map_err(|err| format!("Failed to parse options: {err:?}"))?
+        } else {
+            LatestEpochOptions::default()
+        };
+        Ok(options)
+    }
+}
+
 #[derive(Serialize)]
 struct MithrilEventWasm {
     #[serde(rename = "type")]
@@ -378,6 +396,7 @@ impl MithrilClient {
     }
 
     /// Call the client to get a cardano stake distribution from an epoch
+    ///
     /// The epoch represents the epoch at the end of which the Cardano stake distribution is computed by the Cardano node
     #[wasm_bindgen]
     pub async fn get_cardano_stake_distribution_by_epoch(&self, epoch: u64) -> WasmResult {
@@ -394,6 +413,28 @@ impl MithrilClient {
         Ok(serde_wasm_bindgen::to_value(&result)?)
     }
 
+    /// Call the client to get a cardano stake distribution from an epoch
+    #[wasm_bindgen]
+    pub async fn get_cardano_stake_distribution_for_latest_epoch(
+        &self,
+        param: JsValue,
+    ) -> WasmResult {
+        let options = LatestEpochOptions::parse_from_js_value(param)?;
+        let client = self.client.cardano_stake_distribution();
+
+        let result = match options.offset {
+            None => client.get_for_latest_epoch().await,
+            Some(offset) => client.get_for_latest_epoch_with_offset(offset).await,
+        }
+        .map_err(|err| format!("{err:?}"))?
+        .ok_or(JsValue::from_str(&format!(
+            "No cardano stake distribution found for latest epoch{}",
+            options.offset.map(|o| format!(" (offset: {o})")).unwrap_or_default()
+        )))?;
+
+        Ok(serde_wasm_bindgen::to_value(&result)?)
+    }
+
     /// Call the client for the list of available cardano stake distributions
     #[wasm_bindgen]
     pub async fn list_cardano_stake_distributions(&self) -> WasmResult {
@@ -489,6 +530,43 @@ impl MithrilClient {
         Ok(serde_wasm_bindgen::to_value(&result)?)
     }
 
+    /// Call the client for the list of available cardano database snapshots for a given epoch
+    ///
+    /// Warning: this function is unstable and may be modified in the future
+    #[wasm_bindgen]
+    pub async fn list_cardano_database_v2_per_epoch(&self, epoch: u64) -> WasmResult {
+        self.guard_unstable()?;
+
+        let result = self
+            .client
+            .cardano_database_v2()
+            .list_by_epoch(Epoch(epoch))
+            .await
+            .map_err(|err| format!("{err:?}"))?;
+
+        Ok(serde_wasm_bindgen::to_value(&result)?)
+    }
+
+    /// Call the client for the list of available cardano database snapshots for the latest epoch
+    ///
+    /// An optionnal offset can be provided
+    ///
+    /// Warning: this function is unstable and may be modified in the future
+    #[wasm_bindgen]
+    pub async fn list_cardano_database_v2_for_latest_epoch(&self, param: JsValue) -> WasmResult {
+        self.guard_unstable()?;
+        let options = LatestEpochOptions::parse_from_js_value(param)?;
+        let client = self.client.cardano_database_v2();
+
+        let result = match options.offset {
+            None => client.list_for_latest_epoch().await,
+            Some(offset) => client.list_for_latest_epoch_with_offset(offset).await,
+        }
+        .map_err(|err| format!("{err:?}"))?;
+
+        Ok(serde_wasm_bindgen::to_value(&result)?)
+    }
+
     /// `unstable` Reset the certificate verifier cache if enabled
     #[wasm_bindgen]
     pub async fn reset_certificate_verifier_cache(&self) -> Result<(), JsValue> {
@@ -915,6 +993,42 @@ mod tests {
             .expect_err("get_cardano_stake_distribution_by_epoch should fail");
     }
 
+    #[wasm_bindgen_test]
+    async fn get_cardano_stake_distribution_for_latest_epoch_should_return_value_convertible_in_rust_type()
+     {
+        let latest_epoch = *test_data::cardano_stake_distribution_epochs().last().unwrap();
+        let csd_js_value = get_mithril_client_stable()
+            .get_cardano_stake_distribution_for_latest_epoch(JsValue::undefined())
+            .await
+            .expect("get_cardano_stake_distribution_by_epoch should not fail");
+
+        let csd = serde_wasm_bindgen::from_value::<CardanoStakeDistribution>(csd_js_value)
+            .expect("conversion should not fail");
+
+        assert_eq!(csd.epoch, latest_epoch);
+    }
+
+    #[wasm_bindgen_test]
+    async fn get_cardano_stake_distribution_for_latest_epoch_with_offset_should_return_value_convertible_in_rust_type()
+     {
+        let epoch = test_data::cardano_stake_distribution_epochs()
+            .into_iter()
+            .rev()
+            .nth(2)
+            .unwrap();
+        let csd_js_value = get_mithril_client_stable()
+            .get_cardano_stake_distribution_for_latest_epoch(
+                serde_wasm_bindgen::to_value(&LatestEpochOptions { offset: Some(2) }).unwrap(),
+            )
+            .await
+            .expect("get_cardano_stake_distribution_by_epoch should not fail");
+
+        let csd = serde_wasm_bindgen::from_value::<CardanoStakeDistribution>(csd_js_value)
+            .expect("conversion should not fail");
+
+        assert_eq!(csd.epoch, epoch);
+    }
+
     #[wasm_bindgen_test]
     async fn compute_cardano_stake_distribution_message_should_return_value_convertible_in_rust_type()
      {
@@ -954,6 +1068,64 @@ mod tests {
         );
     }
 
+    #[wasm_bindgen_test]
+    async fn list_cardano_database_v2_per_epoch_should_return_value_convertible_in_rust_type() {
+        let cdb_list_js_value = get_mithril_client_unstable()
+            .list_cardano_database_v2_per_epoch(test_data::cardano_database_snapshot_epochs()[3])
+            .await
+            .expect("list_cardano_database_v2 should not fail");
+        let cdb_list = serde_wasm_bindgen::from_value::<Vec<CardanoDatabaseSnapshotListItem>>(
+            cdb_list_js_value,
+        )
+        .expect("conversion should not fail");
+
+        assert!(!cdb_list.is_empty());
+        assert_eq!(
+            cdb_list[0].beacon.epoch,
+            test_data::cardano_database_snapshot_epochs()[3]
+        );
+    }
+
+    #[wasm_bindgen_test]
+    async fn list_cardano_database_v2_for_latest_epoch_should_return_value_convertible_in_rust_type()
+     {
+        let latest_epoch = *test_data::cardano_database_snapshot_epochs().last().unwrap();
+        let cdb_list_js_value = get_mithril_client_unstable()
+            .list_cardano_database_v2_for_latest_epoch(JsValue::undefined())
+            .await
+            .expect("list_cardano_database_v2 should not fail");
+        let cdb_list = serde_wasm_bindgen::from_value::<Vec<CardanoDatabaseSnapshotListItem>>(
+            cdb_list_js_value,
+        )
+        .expect("conversion should not fail");
+
+        assert!(!cdb_list.is_empty());
+        assert_eq!(cdb_list[0].beacon.epoch, latest_epoch);
+    }
+
+    #[wasm_bindgen_test]
+    async fn list_cardano_database_v2_for_latest_epoch_with_offset_should_return_value_convertible_in_rust_type()
+     {
+        let epoch = test_data::cardano_database_snapshot_epochs()
+            .into_iter()
+            .rev()
+            .nth(3)
+            .unwrap();
+        let cdb_list_js_value = get_mithril_client_unstable()
+            .list_cardano_database_v2_for_latest_epoch(
+                serde_wasm_bindgen::to_value(&LatestEpochOptions { offset: Some(3) }).unwrap(),
+            )
+            .await
+            .expect("list_cardano_database_v2 should not fail");
+        let cdb_list = serde_wasm_bindgen::from_value::<Vec<CardanoDatabaseSnapshotListItem>>(
+            cdb_list_js_value,
+        )
+        .expect("conversion should not fail");
+
+        assert!(!cdb_list.is_empty());
+        assert_eq!(cdb_list[0].beacon.epoch, epoch);
+    }
+
     #[wasm_bindgen_test]
     async fn get_cardano_database_v2_should_return_value_convertible_in_rust_type() {
         let cdb_js_value = get_mithril_client_unstable()