feat(defi): dashboard for blob store canister (#9286)

Follow-up on #8937 to add an `http_request` endpoint serving an HTML
dashboard at `/dashboard`, showing blob store metadata (total blobs,
total size) and a table of all stored blobs with hash, uploader, size,
insertion time, and tags.

Example of rendered dashboard:
<img width="1049" height="338" alt="Screenshot 2026-03-10 at 11 54 51"
src="https://github.com/user-attachments/assets/4bdbf2b7-0669-4d50-9aef-b7c84911aaf1"
/>

Author: gregorydemay

Cargo.lock

@@ -12,16 +12,19 @@ rust_library(
             "src/main.rs",
         ],
     ),
+    compile_data = ["templates/dashboard.html"],
     crate_name = "blob_store_lib",
     deps = [
         # Keep sorted.
+        "@crate_index//:askama",
         "@crate_index//:candid",
         "@crate_index//:ciborium",
         "@crate_index//:hex",
         "@crate_index//:ic-cdk",
         "@crate_index//:ic-stable-structures",
         "@crate_index//:serde",
         "@crate_index//:sha2",
+        "@crate_index//:time",
     ],
 )
 
@@ -31,6 +34,7 @@ rust_test(
     deps = [
         # Keep sorted.
         ":lib",
+        "@crate_index//:scraper",
     ],
 )
 
@@ -41,8 +45,11 @@ rust_canister(
     deps = [
         # Keep sorted.
         ":lib",
+        "//packages/ic-http-types",
+        "@crate_index//:askama",
         "@crate_index//:candid",
         "@crate_index//:ic-cdk",
+        "@crate_index//:serde_bytes",
     ],
 )
 

rs/cross-chain/blob_store/BUILD.bazel

@@ -15,15 +15,20 @@ name = "blob_store_lib"
 path = "src/lib.rs"
 
 [dependencies]
+askama = { workspace = true }
 candid = { workspace = true }
 ciborium = { workspace = true }
 hex = { workspace = true }
 ic-cdk = { workspace = true }
+ic-http-types = { path = "../../../packages/ic-http-types" }
 ic-stable-structures = { workspace = true }
 serde = { workspace = true }
+serde_bytes = { workspace = true }
 sha2 = { workspace = true }
+time = { workspace = true }
 
 [dev-dependencies]
 assert_matches = { workspace = true }
 candid_parser = { workspace = true }
 pocket-ic = { path = "../../../packages/pocket-ic" }
+scraper = "0.17.1"

rs/cross-chain/blob_store/Cargo.toml

@@ -67,3 +67,12 @@ Query metadata (uploader, insertion time, size, tags) without downloading the bl
 ```bash
 icp canister call blob_store get_metadata "(\"$HASH\")"
 ```
+
+### View the dashboard
+
+The dashboard can be found at http://t63gs-up777-77776-aaaba-cai.raw.localhost:8000/dashboard:
+* Adapt the canister ID if needed. This should be visible in the output of `icp deploy`.
+    ```
+    Created canister blob_store with ID t63gs-up777-77776-aaaba-cai
+    ```
+* Note the `raw` part of the URL to bypass certification.

rs/cross-chain/blob_store/README.md

@@ -0,0 +1,63 @@
+use crate::storage::read_blob_store;
+use askama::Template;
+
+#[cfg(test)]
+mod tests;
+
+mod filters {
+    #[askama::filter_fn]
+    pub fn timestamp_to_datetime<T: std::fmt::Display>(
+        timestamp: T,
+        _env: &dyn askama::Values,
+    ) -> askama::Result<String> {
+        let input = timestamp.to_string();
+        let ts: i128 = input
+            .parse()
+            .map_err(|e| askama::Error::Custom(Box::new(e)))?;
+        let dt_offset = time::OffsetDateTime::from_unix_timestamp_nanos(ts).unwrap();
+        let format =
+            time::format_description::parse("[year]-[month]-[day]T[hour]:[minute]:[second]+00:00")
+                .unwrap();
+        Ok(dt_offset.format(&format).unwrap())
+    }
+}
+
+#[derive(Template)]
+#[template(path = "dashboard.html", whitespace = "suppress")]
+pub struct DashboardTemplate {
+    pub total_blobs: u64,
+    pub total_size_bytes: u64,
+    pub blobs: Vec<DashboardBlob>,
+}
+
+pub struct DashboardBlob {
+    pub hash: String,
+    pub uploader: String,
+    pub size: u64,
+    pub inserted_at_ns: u64,
+    pub tags: Vec<String>,
+}
+
+pub fn dashboard() -> DashboardTemplate {
+    read_blob_store(|store| {
+        let mut total_size_bytes = 0u64;
+        let blobs: Vec<DashboardBlob> = store
+            .iter_metadata()
+            .map(|(hash, metadata)| {
+                total_size_bytes += metadata.size;
+                DashboardBlob {
+                    hash: hash.to_string(),
+                    uploader: metadata.uploader.to_string(),
+                    size: metadata.size,
+                    inserted_at_ns: metadata.inserted_at_ns,
+                    tags: metadata.tags.into_iter().map(|t| t.to_string()).collect(),
+                }
+            })
+            .collect();
+        DashboardTemplate {
+            total_blobs: store.len(),
+            total_size_bytes,
+            blobs,
+        }
+    })
+}

rs/cross-chain/blob_store/src/dashboard/mod.rs

@@ -0,0 +1,117 @@
+use crate::dashboard::{DashboardBlob, DashboardTemplate};
+use askama::Template;
+use scraper::{Html, Selector};
+
+#[test]
+fn should_render_empty_dashboard() {
+    let dashboard = DashboardTemplate {
+        total_blobs: 0,
+        total_size_bytes: 0,
+        blobs: vec![],
+    };
+    let html = dashboard.render().unwrap();
+    let parsed = Html::parse_document(&html);
+
+    assert_has_text(&parsed, "#total-blobs > td > code", "0");
+    assert_has_text(&parsed, "#total-size > td > code", "0");
+    assert!(
+        parsed
+            .select(&Selector::parse("#blobs").unwrap())
+            .next()
+            .is_none(),
+        "expected no blobs section"
+    );
+}
+
+#[test]
+fn should_render_blobs() {
+    let dashboard = DashboardTemplate {
+        total_blobs: 2,
+        total_size_bytes: 300,
+        blobs: vec![
+            DashboardBlob {
+                hash: "98ac5cfe873a7b42b7c98a1b3fbeff2255e340deb9c80aa9eb0bd0ba3a0d2a99"
+                    .to_string(),
+                uploader: "principal-1".to_string(),
+                size: 100,
+                inserted_at_ns: 1_700_000_000_000_000_000,
+                tags: vec!["ledger".to_string(), "u256".to_string()],
+            },
+            DashboardBlob {
+                hash: "3d33f9edeae50572a42378d1eaaa29f5149543ec16268797b058156b1b575a04"
+                    .to_string(),
+                uploader: "principal-2".to_string(),
+                size: 200,
+                inserted_at_ns: 1_700_000_001_000_000_000,
+                tags: vec![],
+            },
+        ],
+    };
+    let html = dashboard.render().unwrap();
+    let parsed = Html::parse_document(&html);
+
+    assert_has_text(&parsed, "#total-blobs > td > code", "2");
+    assert_has_text(&parsed, "#total-size > td > code", "300");
+
+    assert_row_contains(
+        &parsed,
+        1,
+        "98ac5cfe873a7b42b7c98a1b3fbeff2255e340deb9c80aa9eb0bd0ba3a0d2a99",
+        "principal-1",
+        "100",
+        &["ledger", "u256"],
+    );
+    assert_row_contains(
+        &parsed,
+        2,
+        "3d33f9edeae50572a42378d1eaaa29f5149543ec16268797b058156b1b575a04",
+        "principal-2",
+        "200",
+        &[],
+    );
+}
+
+fn assert_has_text(html: &Html, selector: &str, expected: &str) {
+    let sel = Selector::parse(selector).unwrap();
+    let element = html
+        .select(&sel)
+        .next()
+        .unwrap_or_else(|| panic!("selector '{selector}' not found"));
+    let text: String = element.text().collect();
+    assert_eq!(text, expected, "selector '{selector}'");
+}
+
+fn assert_row_contains(
+    html: &Html,
+    row: usize,
+    hash: &str,
+    uploader: &str,
+    size: &str,
+    tags: &[&str],
+) {
+    let row_sel =
+        Selector::parse(&format!("#blobs + table > tbody > tr:nth-child({row})")).unwrap();
+    let row_el = html
+        .select(&row_sel)
+        .next()
+        .unwrap_or_else(|| panic!("row {row} not found"));
+    let cells: Vec<String> = row_el
+        .select(&Selector::parse("td").unwrap())
+        .map(|td| td.text().collect::<String>())
+        .collect();
+    assert_eq!(cells[0], hash, "hash mismatch in row {row}");
+    assert_eq!(cells[1], uploader, "uploader mismatch in row {row}");
+    assert_eq!(cells[2], size, "size mismatch in row {row}");
+    // cells[3] is the formatted timestamp, just check it's not empty
+    assert!(!cells[3].is_empty(), "timestamp missing in row {row}");
+    let tag_sel = Selector::parse(".tag").unwrap();
+    let actual_tags: Vec<String> = row_el
+        .select(&tag_sel)
+        .map(|el| el.text().collect::<String>())
+        .collect();
+    assert_eq!(
+        actual_tags,
+        tags.iter().map(|s| s.to_string()).collect::<Vec<_>>(),
+        "tags mismatch in row {row}"
+    );
+}

rs/cross-chain/blob_store/src/dashboard/tests.rs

@@ -1,4 +1,5 @@
 pub mod api;
+pub mod dashboard;
 pub mod query;
 pub mod storage;
 pub mod update;

rs/cross-chain/blob_store/src/lib.rs

@@ -1,4 +1,5 @@
 use blob_store_lib::api::{BlobMetadata, GetError, InsertError, InsertRequest};
+use ic_http_types as http;
 
 #[ic_cdk::init]
 fn init() {}
@@ -27,6 +28,27 @@ fn insert(request: InsertRequest) -> Result<String, InsertError> {
     .map(|hash| hash.to_string())
 }
 
+#[ic_cdk::query(hidden = true)]
+fn http_request(req: http::HttpRequest) -> http::HttpResponse {
+    if ic_cdk::api::in_replicated_execution() {
+        ic_cdk::trap("update call rejected");
+    }
+
+    match req.path() {
+        "/dashboard" => {
+            use askama::Template;
+            let dashboard = blob_store_lib::dashboard::dashboard().render().unwrap();
+            http::HttpResponseBuilder::ok()
+                .header("Content-Type", "text/html; charset=utf-8")
+                .with_body_and_content_length(dashboard)
+                .build()
+        }
+        _ => http::HttpResponseBuilder::not_found()
+            .with_body_and_content_length("not found")
+            .build(),
+    }
+}
+
 fn main() {}
 
 #[test]

rs/cross-chain/blob_store/src/main.rs

@@ -73,6 +73,18 @@ impl<M: Memory> BlobStore<M> {
         self.metadata.get(&hash)
     }
 
+    pub fn len(&self) -> u64 {
+        self.store.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.store.is_empty()
+    }
+
+    pub fn iter_metadata(&self) -> impl Iterator<Item = (Hash, Metadata)> + '_ {
+        self.metadata.iter()
+    }
+
     pub fn insert<B: Into<Blob>>(&mut self, blob: B, metadata: Metadata) -> Option<Hash> {
         let Blob { data, hash } = blob.into();
         if self.store.contains_key(&hash) {