feat: take stab at building block info to hand off

Author: lowhung

Cargo.lock

@@ -24,6 +24,7 @@ async-compression = { version = "0.4.32", features = ["tokio", "gzip"] }
 reqwest = { version = "0.12", features = ["stream"] }
 futures-util = "0.3.31"
 tokio-util = "0.7.17"
+hex = "0.4.3"
 
 [dev-dependencies]
 wiremock = "0.6.5"

modules/snapshot_bootstrapper/Cargo.toml

@@ -6,6 +6,7 @@ mod publisher;
 use crate::configuration::{ConfigError, NetworkConfig, SnapshotConfig, SnapshotFileMetadata};
 use crate::downloader::{DownloadError, SnapshotDownloader};
 use crate::publisher::SnapshotPublisher;
+use acropolis_common::genesis_values::GenesisValues;
 use acropolis_common::snapshot::streaming_snapshot::StreamingSnapshotParser;
 use acropolis_common::{
     messages::{CardanoMessage, Message},
@@ -180,11 +181,15 @@ impl SnapshotBootstrapper {
             Self::parse_snapshot(&file_path, &mut publisher).await?;
         }
 
-        let metadata = publisher
-            .metadata()
-            .ok_or_else(|| anyhow::anyhow!("No metadata received from snapshots"))?;
+        let last_snapshot =
+            snapshots.last().ok_or_else(|| anyhow::anyhow!("No snapshots to process"))?;
+
+        let block_info = build_block_info_from_metadata(last_snapshot).map_err(|e| {
+            BootstrapError::Parse(format!(
+                "Failed to build block info from snapshot metadata: {e}"
+            ))
+        })?;
 
-        let block_info = build_block_info_from_metadata(metadata);
         publisher.publish_completion(block_info).await?;
 
         Ok(())
@@ -204,18 +209,32 @@ impl SnapshotBootstrapper {
     }
 }
 
-fn build_block_info_from_metadata(
-    metadata: &acropolis_common::snapshot::streaming_snapshot::SnapshotMetadata,
-) -> BlockInfo {
-    BlockInfo {
+fn build_block_info_from_metadata(metadata: &SnapshotFileMetadata) -> Result<BlockInfo> {
+    let (slot, block_hash_str) = metadata
+        .parse_point()
+        .ok_or_else(|| anyhow::anyhow!("Invalid point format: {}", metadata.point))?;
+
+    let hash = BlockHash::try_from(hex::decode(block_hash_str)?)
+        .map_err(|e| anyhow::anyhow!("Invalid block hash hex: {:?}", e))?;
+
+    let genesis = GenesisValues::mainnet();
+    let epoch_slot = slot - genesis.epoch_to_first_slot(slot);
+    let timestamp = genesis.slot_to_timestamp(slot);
+
+    info!(
+        "Block info built: slot={}, hash={}, epoch={}, slot_in_epoch={}, timestamp={}",
+        slot, hash, metadata.epoch, epoch_slot, timestamp
+    );
+
+    Ok(BlockInfo {
         status: BlockStatus::Immutable,
-        slot: 0,
+        slot,
         number: 0,
-        hash: BlockHash::default(),
+        hash,
         epoch: metadata.epoch,
-        epoch_slot: 0,
+        epoch_slot,
         new_epoch: false,
-        timestamp: 0,
+        timestamp,
         era: Era::Conway,
-    }
+    })
 }

modules/snapshot_bootstrapper/src/bootstrapper.rs

@@ -108,6 +108,17 @@ impl SnapshotFileMetadata {
         Ok(snapshots)
     }
 
+    pub fn parse_point(&self) -> Option<(u64, String)> {
+        let parts: Vec<&str> = self.point.splitn(2, '.').collect();
+        if parts.len() == 2 {
+            let slot = parts[0].parse().ok()?;
+            let hash = parts[1].to_string();
+            Some((slot, hash))
+        } else {
+            None
+        }
+    }
+
     pub fn file_path(&self, network_dir: &str) -> String {
         format!("{}/{}.cbor", network_dir, self.point)
     }

modules/snapshot_bootstrapper/src/configuration.rs

@@ -58,10 +58,6 @@ impl SnapshotPublisher {
         )));
         self.context.publish(&self.completion_topic, message).await
     }
-
-    pub fn metadata(&self) -> Option<&SnapshotMetadata> {
-        self.metadata.as_ref()
-    }
 }
 
 impl UtxoCallback for SnapshotPublisher {