|
| 1 | +#![allow(dead_code, unused)] |
| 2 | +use acropolis_common::hash::Hash; |
| 3 | +use acropolis_common::Point; |
| 4 | +use pallas_primitives::babbage::MintedHeader; |
| 5 | +use pallas_primitives::conway::Header as ConwayHeader; |
| 6 | +use std::fs; |
| 7 | +use std::path::{Path, PathBuf}; |
| 8 | +use thiserror::Error; |
| 9 | + |
| 10 | +#[derive(Debug, Error)] |
| 11 | +pub enum HeaderContextError { |
| 12 | + #[error("Failed to read header file {0}: {1}")] |
| 13 | + ReadFile(PathBuf, std::io::Error), |
| 14 | + |
| 15 | + #[error("Failed to decode header at slot {0}: {1}")] |
| 16 | + Decode(u64, String), |
| 17 | + |
| 18 | + #[error("Origin point has no hash")] |
| 19 | + OriginPoint, |
| 20 | + |
| 21 | + #[error("Failed to convert hash: {0}")] |
| 22 | + HashConversion(String), |
| 23 | +} |
| 24 | + |
| 25 | +#[derive(Debug)] |
| 26 | +pub struct HeaderContext { |
| 27 | + pub point: Point, |
| 28 | + pub block_number: u64, |
| 29 | +} |
| 30 | + |
| 31 | +impl HeaderContext { |
| 32 | + /// Generate the path for a header file. |
| 33 | + /// Returns an error if the point is Origin (has no hash). |
| 34 | + pub fn path(network_dir: &Path, point: &Point) -> Result<PathBuf, HeaderContextError> { |
| 35 | + let hash = point.hash().ok_or(HeaderContextError::OriginPoint)?; |
| 36 | + let filename = format!("header.{}.{}.cbor", point.slot(), hash); |
| 37 | + Ok(network_dir.join("headers").join(filename)) |
| 38 | + } |
| 39 | + |
| 40 | + /// Convert raw hash bytes to our Hash type. |
| 41 | + pub fn convert_hash(block_body_hash: &[u8]) -> Result<Hash<32>, HeaderContextError> { |
| 42 | + block_body_hash |
| 43 | + .try_into() |
| 44 | + .map_err(|_| HeaderContextError::HashConversion(format!("{:02x?}", block_body_hash))) |
| 45 | + } |
| 46 | + |
| 47 | + /// Load and decode header from `headers/header.{slot}.{hash}.cbor` |
| 48 | + pub fn load(network_dir: &Path, point: &Point) -> Result<Self, HeaderContextError> { |
| 49 | + let path = Self::path(network_dir, point)?; |
| 50 | + let cbor = fs::read(&path).map_err(|e| HeaderContextError::ReadFile(path, e))?; |
| 51 | + |
| 52 | + let minted: MintedHeader<'_> = minicbor::decode(&cbor) |
| 53 | + .map_err(|e| HeaderContextError::Decode(point.slot(), e.to_string()))?; |
| 54 | + let header = ConwayHeader::from(minted); |
| 55 | + Ok(Self { |
| 56 | + point: point.clone(), |
| 57 | + block_number: header.header_body.block_number, |
| 58 | + }) |
| 59 | + } |
| 60 | +} |
| 61 | + |
| 62 | +#[cfg(test)] |
| 63 | +mod header_tests { |
| 64 | + use super::*; |
| 65 | + use std::fs; |
| 66 | + use tempfile::TempDir; |
| 67 | + |
| 68 | + fn specific_point(slot: u64, hash_str: &str) -> Point { |
| 69 | + Point::Specific { |
| 70 | + slot, |
| 71 | + hash: hash_str.parse().expect("valid hash"), |
| 72 | + } |
| 73 | + } |
| 74 | + |
| 75 | + fn setup_headers_dir() -> TempDir { |
| 76 | + let temp_dir = TempDir::new().unwrap(); |
| 77 | + fs::create_dir_all(temp_dir.path().join("headers")).unwrap(); |
| 78 | + temp_dir |
| 79 | + } |
| 80 | + |
| 81 | + const ZERO_HASH: &str = "0000000000000000000000000000000000000000000000000000000000000000"; |
| 82 | + |
| 83 | + #[test] |
| 84 | + fn path_fails_for_origin_point() { |
| 85 | + let result = HeaderContext::path(Path::new("/test"), &Point::Origin); |
| 86 | + |
| 87 | + let err = result.unwrap_err(); |
| 88 | + assert!(matches!(err, HeaderContextError::OriginPoint)); |
| 89 | + assert_eq!(err.to_string(), "Origin point has no hash"); |
| 90 | + } |
| 91 | + |
| 92 | + #[test] |
| 93 | + fn path_succeeds_for_specific_point() { |
| 94 | + let point = specific_point(42, ZERO_HASH); |
| 95 | + |
| 96 | + let path = HeaderContext::path(Path::new("/test"), &point).unwrap(); |
| 97 | + |
| 98 | + assert!(path.ends_with(format!("headers/header.42.{}.cbor", ZERO_HASH))); |
| 99 | + } |
| 100 | + |
| 101 | + #[test] |
| 102 | + fn convert_hash_fails_for_wrong_length() { |
| 103 | + // Too short |
| 104 | + assert!(matches!( |
| 105 | + HeaderContext::convert_hash(&[0u8; 16]), |
| 106 | + Err(HeaderContextError::HashConversion(_)) |
| 107 | + )); |
| 108 | + |
| 109 | + // Too long |
| 110 | + assert!(matches!( |
| 111 | + HeaderContext::convert_hash(&[0u8; 64]), |
| 112 | + Err(HeaderContextError::HashConversion(_)) |
| 113 | + )); |
| 114 | + } |
| 115 | + |
| 116 | + #[test] |
| 117 | + fn convert_hash_succeeds_for_32_bytes() { |
| 118 | + let bytes = [0xab; 32]; |
| 119 | + assert!(HeaderContext::convert_hash(&bytes).is_ok()); |
| 120 | + } |
| 121 | + |
| 122 | + #[test] |
| 123 | + fn hash_conversion_error_includes_hex_representation() { |
| 124 | + let err = HeaderContext::convert_hash(&[0xde, 0xad, 0xbe, 0xef]).unwrap_err(); |
| 125 | + let msg = err.to_string().to_lowercase(); |
| 126 | + |
| 127 | + assert!(msg.contains("de") && msg.contains("ad")); |
| 128 | + } |
| 129 | + |
| 130 | + #[test] |
| 131 | + fn load_fails_for_origin_point() { |
| 132 | + let temp_dir = setup_headers_dir(); |
| 133 | + |
| 134 | + let err = HeaderContext::load(temp_dir.path(), &Point::Origin).unwrap_err(); |
| 135 | + |
| 136 | + assert!(matches!(err, HeaderContextError::OriginPoint)); |
| 137 | + } |
| 138 | + |
| 139 | + #[test] |
| 140 | + fn load_fails_when_file_missing() { |
| 141 | + let temp_dir = setup_headers_dir(); |
| 142 | + let point = specific_point(12345, ZERO_HASH); |
| 143 | + |
| 144 | + let err = HeaderContext::load(temp_dir.path(), &point).unwrap_err(); |
| 145 | + |
| 146 | + assert!(matches!(err, HeaderContextError::ReadFile(_, _))); |
| 147 | + assert!(err.to_string().contains("header.12345")); |
| 148 | + } |
| 149 | + |
| 150 | + #[test] |
| 151 | + fn load_fails_for_invalid_cbor() { |
| 152 | + let temp_dir = setup_headers_dir(); |
| 153 | + let point = specific_point(12345, ZERO_HASH); |
| 154 | + let path = HeaderContext::path(temp_dir.path(), &point).unwrap(); |
| 155 | + fs::write(&path, b"not valid cbor").unwrap(); |
| 156 | + |
| 157 | + let err = HeaderContext::load(temp_dir.path(), &point).unwrap_err(); |
| 158 | + |
| 159 | + assert!(matches!(err, HeaderContextError::Decode(12345, _))); |
| 160 | + } |
| 161 | + |
| 162 | + #[test] |
| 163 | + fn load_fails_for_wrong_cbor_structure() { |
| 164 | + let temp_dir = setup_headers_dir(); |
| 165 | + let point = specific_point(555, ZERO_HASH); |
| 166 | + let path = HeaderContext::path(temp_dir.path(), &point).unwrap(); |
| 167 | + fs::write(&path, minicbor::to_vec(42u64).unwrap()).unwrap(); |
| 168 | + |
| 169 | + let err = HeaderContext::load(temp_dir.path(), &point).unwrap_err(); |
| 170 | + |
| 171 | + assert!(matches!(err, HeaderContextError::Decode(555, _))); |
| 172 | + } |
| 173 | +} |
0 commit comments