+1 -2

src/lib.rs

reviewed

··· 12 12 13 13 pub use error::{Result, StarError}; 14 14 pub use parser::StarParser; 15 15 - pub use ser::{StarEncoder, StarSerializer}; 15 15 + pub use ser::{StarEncoder, StarSerializer, StarValidator}; 16 16 pub use types::{RepoMstEntry, RepoMstNode, StarCommit, StarItem, StarMstEntry, StarMstNode}; 17 17 - pub use validation::StarValidator; 18 17 19 18 #[cfg(feature = "blocking")] 20 19 pub use blocking::StarIterator;

+42 -152

src/parser.rs

reviewed

··· 1 1 use crate::error::{Result, StarError}; 2 2 use crate::types::{StarCommit, StarItem, StarMstNode}; 3 3 + use crate::validation::validate_node_structure; 3 4 use cid::Cid; 4 5 use sha2::{Digest, Sha256}; 5 6 6 7 #[derive(Debug)] 7 8 enum State { 8 9 Header, 9 9 - Body { 10 10 + Body { 10 11 stack: Vec<StackItem>, 11 12 current_len: Option<usize>, 12 13 }, ··· 17 18 enum StackItem { 18 19 Node { 19 20 expected: Option<Cid>, 20 20 - expected_height: Option<u32>, // The node at this position must have height exactly == this value (if set) 21 21 + expected_height: Option<u32>, 21 22 }, 22 23 Record { 23 24 key: Vec<u8>, ··· 45 46 46 47 pub fn parse(&mut self, buf: &[u8]) -> Result<(usize, Option<StarItem>)> { 47 48 let mut consumed = 0; 48 48 - 49 49 + 49 50 loop { 50 51 let is_body_done = if let State::Body { stack, .. } = &self.state { 51 52 stack.is_empty() ··· 79 80 Some((n, len)) => (n, len), 80 81 None => return Ok((consumed, None)), 81 82 }; 82 82 - 83 83 + 83 84 let body_buf = &current_buf[len_consumed..]; 84 85 if body_buf.len() < len { 85 86 consumed += len_consumed; ··· 88 89 89 90 let block_bytes = &body_buf[..len]; 90 91 *current_len = None; 91 91 - 92 92 + 92 93 let item = stack.pop().unwrap(); 93 94 let result_item = match item { 94 94 - StackItem::Node { 95 95 - expected, 96 96 - expected_height, 97 97 - } => Self::process_node(block_bytes, expected, expected_height, stack)?, 98 98 - StackItem::Record { 99 99 - key, 100 100 - expected, 101 101 - implicit_index, 102 102 - } => { 95 95 + StackItem::Node { expected, expected_height } => { 96 96 + Self::process_node(block_bytes, expected, expected_height, stack)? 97 97 + }, 98 98 + StackItem::Record { key, expected, implicit_index } => { 103 99 Self::process_record(block_bytes, key, expected, implicit_index, stack)? 104 104 - } 100 100 + }, 105 101 _ => return Err(StarError::InvalidState("Unexpected stack item".into())), 106 102 }; 107 103 ··· 112 108 } 113 109 } 114 110 115 115 - fn calculate_height(key: &[u8]) -> u32 { 116 116 - let digest = Sha256::digest(key); 117 117 - let mut zeros = 0; 118 118 - for &byte in digest.iter() { 119 119 - if byte == 0 { 120 120 - zeros += 8; 121 121 - } else { 122 122 - zeros += byte.leading_zeros(); 123 123 - break; 124 124 - } 125 125 - } 126 126 - zeros / 2 127 127 - } 128 128 - 129 111 fn parse_header(&mut self, buf: &[u8]) -> Result<Option<(usize, StarItem)>> { 130 112 if buf.len() < 1 { 131 113 return Ok(None); ··· 135 117 } 136 118 137 119 let slice = &buf[1..]; 138 138 - 120 120 + 139 121 let (ver, remaining1) = match unsigned_varint::decode::usize(slice) { 140 122 Ok(res) => res, 141 123 Err(unsigned_varint::decode::Error::Insufficient) => return Ok(None), 142 124 Err(e) => return Err(StarError::InvalidState(format!("Varint error: {}", e))), 143 125 }; 144 144 - 126 126 + 145 127 let (len, remaining2) = match unsigned_varint::decode::usize(remaining1) { 146 128 Ok(res) => res, 147 129 Err(unsigned_varint::decode::Error::Insufficient) => return Ok(None), 148 130 Err(e) => return Err(StarError::InvalidState(format!("Varint error: {}", e))), 149 131 }; 150 132 151 151 - let header_varints_len = buf.len() - 1 - remaining2.len(); 152 152 - let total_header_len = 1 + header_varints_len; 133 133 + let header_varints_len = buf.len() - 1 - remaining2.len(); 134 134 + let total_header_len = 1 + header_varints_len; 153 135 let total_len = total_header_len + len; 154 136 155 137 if buf.len() < total_len { ··· 159 141 let commit_bytes = &buf[total_header_len..total_len]; 160 142 let commit: StarCommit = serde_ipld_dagcbor::from_slice(commit_bytes) 161 143 .map_err(|e| StarError::Cbor(e.to_string()))?; 162 162 - 163 163 - let _ = ver; 144 144 + 145 145 + let _ = ver; 164 146 165 147 let mut stack = Vec::new(); 166 148 if let Some(root_cid) = commit.data { ··· 170 152 }); 171 153 } 172 154 173 173 - self.state = State::Body { 155 155 + self.state = State::Body { 174 156 stack, 175 175 - current_len: None, 157 157 + current_len: None 176 158 }; 177 159 Ok(Some((total_len, StarItem::Commit(commit)))) 178 160 } ··· 223 205 let consumed = buf.len() - remaining.len(); 224 206 *current_len = Some(l); 225 207 Ok(Some((consumed, l))) 226 226 - } 208 208 + }, 227 209 Err(unsigned_varint::decode::Error::Insufficient) => Ok(None), 228 210 Err(e) => Err(StarError::InvalidState(format!("Varint error: {}", e))), 229 211 } 230 212 } 231 213 232 232 - fn process_node( 233 233 - block_bytes: &[u8], 234 234 - expected: Option<Cid>, 235 235 - expected_height: Option<u32>, 236 236 - stack: &mut Vec<StackItem>, 237 237 - ) -> Result<Option<StarItem>> { 214 214 + fn process_node(block_bytes: &[u8], expected: Option<Cid>, expected_height: Option<u32>, stack: &mut Vec<StackItem>) -> Result<Option<StarItem>> { 238 215 let node: StarMstNode = serde_ipld_dagcbor::from_slice(block_bytes) 239 216 .map_err(|e| StarError::Cbor(e.to_string()))?; 240 217 241 241 - // We run the loop to reconstruct keys and validate their internal consistency first. 242 242 - let mut prev_key_bytes = Vec::new(); 243 243 - let mut entry_keys = Vec::new(); 244 244 - let mut node_height = None; 245 245 - 246 246 - for e in &node.e { 247 247 - let mut key = if e.p as usize <= prev_key_bytes.len() { 248 248 - prev_key_bytes[..e.p as usize].to_vec() 249 249 - } else { 250 250 - prev_key_bytes.clone() 251 251 - }; 252 252 - key.extend_from_slice(&e.k); 253 253 - 254 254 - let h = Self::calculate_height(&key); 255 255 - 256 256 - if let Some(existing_h) = node_height { 257 257 - if h != existing_h { 258 258 - return Err(StarError::InvalidState(format!( 259 259 - "Inconsistent key height in node: {} vs {}", 260 260 - h, existing_h 261 261 - ))); 262 262 - } 263 263 - } else { 264 264 - node_height = Some(h); 265 265 - } 266 266 - 267 267 - entry_keys.push(key.clone()); 268 268 - prev_key_bytes = key; 269 269 - } 270 270 - 271 271 - // 2. Validate Height against Expectation 272 272 - let height = match (node_height, expected_height) { 273 273 - (Some(h), Some(exp)) => { 274 274 - if h != exp { 275 275 - return Err(StarError::InvalidState(format!( 276 276 - "Invalid MST height: found {}, expected {}", 277 277 - h, exp 278 278 - ))); 279 279 - } 280 280 - h 281 281 - } 282 282 - (Some(h), None) => { 283 283 - // Root node with keys. 284 284 - h 285 285 - } 286 286 - (None, Some(exp)) => { 287 287 - // Empty node (intermediate). Must match expectation. 288 288 - // Constraint: Height 0 cannot be empty. 289 289 - if exp == 0 { 290 290 - return Err(StarError::InvalidState( 291 291 - "MST nodes at depth=0 cannot be empty".into(), 292 292 - )); 293 293 - } 294 294 - exp 295 295 - } 296 296 - (None, None) => { 297 297 - // Root node empty. 298 298 - return Err(StarError::InvalidState( 299 299 - "Root node must contain entries".into(), 300 300 - )); 301 301 - } 302 302 - }; 218 218 + // Use shared validation logic 219 219 + let (height, entry_keys) = validate_node_structure(&node, expected_height)?; 303 220 304 304 - // 3. Validate Structure based on Height 221 221 + // Check for implicit records (needed for VerifyLayer0 logic) 222 222 + let mut has_implicit = false; 223 223 + // Optimization: validate_node_structure already ensures consistency of v based on height. 224 224 + // If height == 0, v is None (Implicit). If height > 0, v is Some (Explicit). 305 225 if height == 0 { 306 306 - // Must have no children 307 307 - if node.l.is_some() || node.l_archived.is_some() { 308 308 - return Err(StarError::InvalidState( 309 309 - "Height 0 node cannot have left child".into(), 310 310 - )); 311 311 - } 312 226 for e in &node.e { 313 313 - if e.t.is_some() || e.t_archived.is_some() { 314 314 - return Err(StarError::InvalidState( 315 315 - "Height 0 entries cannot have subtrees".into(), 316 316 - )); 227 227 + if e.v_archived == Some(true) { 228 228 + has_implicit = true; 229 229 + break; 317 230 } 318 231 } 319 319 - } else { 320 320 - // Height > 0 321 321 - if node.e.is_empty() && node.l.is_none() { 322 322 - return Err(StarError::InvalidState( 323 323 - "Empty intermediate node must have left child".into(), 324 324 - )); 325 325 - } 326 326 - } 327 327 - 328 328 - // Check for implicit records 329 329 - let mut has_implicit = false; 330 330 - for e in &node.e { 331 331 - if e.v_archived == Some(true) && e.v.is_none() { 332 332 - has_implicit = true; 333 333 - break; 334 334 - } 335 232 } 336 233 337 234 if !has_implicit { ··· 340 237 .map_err(|e| StarError::Cbor(e.to_string()))?; 341 238 342 239 let hash = Sha256::digest(&bytes); 343 343 - let cid = Cid::new_v1(0x71, cid::multihash::Multihash::wrap(0x12, &hash)?); 240 240 + let cid = Cid::new_v1( 241 241 + 0x71, 242 242 + cid::multihash::Multihash::wrap(0x12, &hash)?, 243 243 + ); 344 244 if let Some(exp) = expected { 345 245 if cid != exp { 346 246 return Err(StarError::VerificationFailed { ··· 359 259 } 360 260 361 261 // Push children in reverse 362 362 - // Expected height for children is strictly height - 1 363 262 let child_expected_height = height.checked_sub(1); 364 364 - 365 365 - // If height is 0, we already verified no children exist, so child_expected_height is None/invalid but unused. 366 366 - // Actually height - 1 would underflow if height 0. But logic ensures no children pushed if height 0. 367 367 - 263 263 + 368 264 if height > 0 { 369 265 let next_h = child_expected_height.unwrap(); 370 370 - 266 266 + 371 267 for i in (0..node.e.len()).rev() { 372 268 let e = &node.e[i]; 373 269 let key = entry_keys[i].clone(); 374 270 375 271 if e.t_archived == Some(true) { 376 376 - stack.push(StackItem::Node { 272 272 + stack.push(StackItem::Node { 377 273 expected: e.t, 378 378 - expected_height: Some(next_h), 274 274 + expected_height: Some(next_h), 379 275 }); 380 276 } 381 277 ··· 390 286 } 391 287 392 288 if node.l_archived == Some(true) { 393 393 - stack.push(StackItem::Node { 289 289 + stack.push(StackItem::Node { 394 290 expected: node.l, 395 291 expected_height: Some(next_h), 396 292 }); 397 293 } 398 294 } else { 399 295 // Height 0: Push records only 400 400 - for i in (0..node.e.len()).rev() { 296 296 + for i in (0..node.e.len()).rev() { 401 297 let e = &node.e[i]; 402 298 let key = entry_keys[i].clone(); 403 403 - 299 299 + 404 300 if e.v_archived == Some(true) { 405 301 let implicit_index = if e.v.is_none() { Some(i) } else { None }; 406 302 stack.push(StackItem::Record { ··· 415 311 Ok(Some(StarItem::Node(node))) 416 312 } 417 313 418 418 - fn process_record( 419 419 - block_bytes: &[u8], 420 420 - key: Vec<u8>, 421 421 - expected: Option<Cid>, 422 422 - implicit_index: Option<usize>, 423 423 - stack: &mut Vec<StackItem>, 424 424 - ) -> Result<Option<StarItem>> { 314 314 + fn process_record(block_bytes: &[u8], key: Vec<u8>, expected: Option<Cid>, implicit_index: Option<usize>, stack: &mut Vec<StackItem>) -> Result<Option<StarItem>> { 425 315 let hash = Sha256::digest(block_bytes); 426 316 let cid = Cid::new_v1(0x71, cid::multihash::Multihash::wrap(0x12, &hash)?); 427 317

+118 -16

src/ser.rs

reviewed

··· 1 1 use crate::error::Result; 2 2 use crate::types::{StarCommit, StarItem, StarMstNode}; 3 3 - use crate::validation::StarValidator; 3 3 + use crate::validation::validate_node_structure; 4 4 + use crate::error::StarError; 4 5 use std::io::Write; 5 6 6 7 pub struct StarEncoder; ··· 14 15 15 16 pub fn write_header<W: Write>(commit: &StarCommit, dst: &mut W) -> Result<()> { 16 17 dst.write_all(&[0x2A])?; 17 17 - 18 18 + 18 19 Self::write_varint(1, dst)?; 19 19 - 20 20 + 20 21 let commit_bytes = serde_ipld_dagcbor::to_vec(commit) 21 22 .map_err(|e| crate::error::StarError::Cbor(e.to_string()))?; 22 22 - 23 23 + 23 24 Self::write_varint(commit_bytes.len(), dst)?; 24 25 dst.write_all(&commit_bytes)?; 25 25 - 26 26 + 26 27 Ok(()) 27 28 } 28 29 29 30 pub fn write_node<W: Write>(node: &StarMstNode, dst: &mut W) -> Result<()> { 30 31 let node_bytes = serde_ipld_dagcbor::to_vec(node) 31 32 .map_err(|e| crate::error::StarError::Cbor(e.to_string()))?; 32 32 - 33 33 + 33 34 Self::write_varint(node_bytes.len(), dst)?; 34 35 dst.write_all(&node_bytes)?; 35 35 - 36 36 + 36 37 Ok(()) 37 38 } 38 39 39 40 pub fn write_record<W: Write>(record_bytes: &[u8], dst: &mut W) -> Result<()> { 40 41 Self::write_varint(record_bytes.len(), dst)?; 41 42 dst.write_all(record_bytes)?; 42 42 - 43 43 + 43 44 Ok(()) 44 45 } 45 46 } ··· 52 53 use bytes::BufMut; 53 54 // BytesMut::writer() returns an impl Write 54 55 let mut writer = dst.writer(); 55 55 - 56 56 + 56 57 match item { 57 58 StarItem::Commit(c) => Self::write_header(&c, &mut writer), 58 59 StarItem::Node(n) => Self::write_node(&n, &mut writer), ··· 60 61 if let Some(bytes) = content { 61 62 Self::write_record(&bytes, &mut writer) 62 63 } else { 63 63 - Err(crate::error::StarError::InvalidState( 64 64 - "Cannot serialize record without content".into(), 65 65 - )) 64 64 + Err(crate::error::StarError::InvalidState("Cannot serialize record without content".into())) 66 65 } 67 66 } 68 67 } ··· 97 96 self.validator.accept_record(record_bytes)?; 98 97 StarEncoder::write_record(record_bytes, &mut self.writer) 99 98 } 100 100 - 99 99 + 101 100 pub fn finish(self) -> Result<W> { 102 101 if !self.validator.is_done() { 103 103 - return Err(crate::error::StarError::InvalidState( 104 104 - "Incomplete tree".into(), 105 105 - )); 102 102 + return Err(crate::error::StarError::InvalidState("Incomplete tree".into())); 106 103 } 107 104 Ok(self.writer) 108 105 } 109 106 } 107 107 + 108 108 + // Validator State Machine (Moved from validation.rs) 109 109 + 110 110 + #[derive(Debug)] 111 111 + pub struct StarValidator { 112 112 + state: ValidatorState, 113 113 + } 114 114 + 115 115 + #[derive(Debug)] 116 116 + enum ValidatorState { 117 117 + Header, 118 118 + Body { stack: Vec<Expectation> }, 119 119 + Done, 120 120 + } 121 121 + 122 122 + #[derive(Debug)] 123 123 + enum Expectation { 124 124 + Root, 125 125 + Node { height: u32 }, 126 126 + Record, 127 127 + } 128 128 + 129 129 + impl StarValidator { 130 130 + pub fn new() -> Self { 131 131 + Self { state: ValidatorState::Header } 132 132 + } 133 133 + 134 134 + pub fn accept_header(&mut self, commit: &StarCommit) -> Result<()> { 135 135 + match &self.state { 136 136 + ValidatorState::Header => { 137 137 + let stack = if commit.data.is_some() { 138 138 + vec![Expectation::Root] 139 139 + } else { 140 140 + Vec::new() // Empty tree 141 141 + }; 142 142 + self.state = ValidatorState::Body { stack }; 143 143 + Ok(()) 144 144 + }, 145 145 + _ => Err(StarError::InvalidState("Header already written or invalid state".into())), 146 146 + } 147 147 + } 148 148 + 149 149 + pub fn accept_node(&mut self, node: &StarMstNode) -> Result<()> { 150 150 + match &mut self.state { 151 151 + ValidatorState::Body { stack } => { 152 152 + if stack.is_empty() { 153 153 + return Err(StarError::InvalidState("Unexpected node: tree is complete".into())); 154 154 + } 155 155 + 156 156 + let expectation = stack.pop().unwrap(); 157 157 + let expected_height = match expectation { 158 158 + Expectation::Record => { 159 159 + return Err(StarError::InvalidState("Expected record, got node".into())); 160 160 + }, 161 161 + Expectation::Root => None, 162 162 + Expectation::Node { height } => Some(height), 163 163 + }; 164 164 + 165 165 + // Use the shared validation logic 166 166 + let (height, _) = validate_node_structure(node, expected_height)?; 167 167 + 168 168 + let child_height = if height > 0 { height - 1 } else { 0 }; 169 169 + 170 170 + for e in node.e.iter().rev() { 171 171 + if e.t_archived == Some(true) { 172 172 + stack.push(Expectation::Node { height: child_height }); 173 173 + } 174 174 + if e.v_archived == Some(true) { 175 175 + stack.push(Expectation::Record); 176 176 + } 177 177 + } 178 178 + 179 179 + if node.l_archived == Some(true) { 180 180 + stack.push(Expectation::Node { height: child_height }); 181 181 + } 182 182 + 183 183 + Ok(()) 184 184 + }, 185 185 + _ => Err(StarError::InvalidState("Invalid state for node".into())), 186 186 + } 187 187 + } 188 188 + 189 189 + pub fn accept_record(&mut self, _bytes: &[u8]) -> Result<()> { 190 190 + match &mut self.state { 191 191 + ValidatorState::Body { stack } => { 192 192 + if stack.is_empty() { 193 193 + return Err(StarError::InvalidState("Unexpected record: tree is complete".into())); 194 194 + } 195 195 + match stack.pop().unwrap() { 196 196 + Expectation::Record => Ok(()), 197 197 + _ => Err(StarError::InvalidState("Expected node, got record".into())), 198 198 + } 199 199 + }, 200 200 + _ => Err(StarError::InvalidState("Invalid state for record".into())), 201 201 + } 202 202 + } 203 203 + 204 204 + pub fn is_done(&self) -> bool { 205 205 + match &self.state { 206 206 + ValidatorState::Body { stack } => stack.is_empty(), 207 207 + ValidatorState::Done => true, 208 208 + _ => false, 209 209 + } 210 210 + } 211 211 + }

+34 -16

src/tests.rs

reviewed

··· 19 19 // 1. Create a dummy record 20 20 let record_data = b"hello world"; 21 21 let record_cid = create_test_cid(record_data); 22 22 - let key = b"foo".to_vec(); 22 22 + let key = b"bar".to_vec(); // Height 0 23 23 24 24 // 2. Create a dummy MST Node (Layer 0, implicit record) 25 25 let node_entry = StarMstEntry { ··· 71 71 let mut parser = StarParser::new(); 72 72 73 73 // Helper to mimic Decoder loop for tests 74 74 - fn parse_helper(parser: &mut StarParser, buf: &mut Vec<u8>, offset: &mut usize) -> Option<StarItem> { 74 74 + fn parse_helper( 75 75 + parser: &mut StarParser, 76 76 + buf: &mut Vec<u8>, 77 77 + offset: &mut usize, 78 78 + ) -> Option<StarItem> { 75 79 let (consumed, item) = parser.parse(&buf[*offset..]).unwrap(); 76 80 *offset += consumed; 77 81 item 78 82 } 79 79 - 83 83 + 80 84 let mut offset = 0; 81 85 82 86 // Header ··· 119 123 fn test_verification_failure() { 120 124 // 1. Create a dummy record 121 125 let record_data = b"hello world"; 122 122 - let key = b"foo".to_vec(); 126 126 + let key = b"bar".to_vec(); // Height 0 123 127 124 128 // 2. Create STAR Node 125 129 let node_entry = StarMstEntry { ··· 156 160 // 5. Parse 157 161 let mut parser = StarParser::new(); 158 162 let mut offset = 0; 159 159 - 160 160 - fn parse_helper(parser: &mut StarParser, buf: &mut Vec<u8>, offset: &mut usize) -> Result<Option<StarItem>, crate::error::StarError> { 163 163 + 164 164 + fn parse_helper( 165 165 + parser: &mut StarParser, 166 166 + buf: &mut Vec<u8>, 167 167 + offset: &mut usize, 168 168 + ) -> Result<Option<StarItem>, crate::error::StarError> { 161 169 let (consumed, item) = parser.parse(&buf[*offset..])?; 162 170 *offset += consumed; 163 171 Ok(item) ··· 166 174 parse_helper(&mut parser, &mut buf, &mut offset).unwrap(); // Header OK 167 175 parse_helper(&mut parser, &mut buf, &mut offset).unwrap(); // Node OK 168 176 parse_helper(&mut parser, &mut buf, &mut offset).unwrap(); // Record OK 169 169 - 177 177 + 170 178 // 6. Trigger verification 171 179 let result = parse_helper(&mut parser, &mut buf, &mut offset); 172 172 - 180 180 + 173 181 assert!(result.is_err()); 174 182 match result.unwrap_err() { 175 175 - crate::error::StarError::VerificationFailed { .. } => {}, 183 183 + crate::error::StarError::VerificationFailed { .. } => {} 176 184 e => panic!("Expected VerificationFailed, got {:?}", e), 177 185 } 178 186 } ··· 182 190 // Test that strict serializer enforces constraints 183 191 let mut buf = Vec::new(); 184 192 let mut serializer = StarSerializer::new(&mut buf); 185 185 - 193 193 + 186 194 // 1. Create invalid node (height 0 but empty) 187 195 let invalid_node = StarMstNode { 188 196 l: None, 189 197 l_archived: None, 190 198 e: vec![], 191 199 }; 192 192 - 200 200 + 193 201 // 2. Commit pointing to root 194 202 let cid = create_test_cid(b"foo"); 195 203 let commit = StarCommit { 196 196 - did: "did".into(), version: 3, data: Some(cid), rev: "1".into(), prev: None, sig: None 204 204 + did: "did".into(), 205 205 + version: 3, 206 206 + data: Some(cid), 207 207 + rev: "1".into(), 208 208 + prev: None, 209 209 + sig: None, 197 210 }; 198 198 - 211 211 + 199 212 // Header OK 200 213 serializer.write_header(&commit).unwrap(); 201 201 - 214 214 + 202 215 // Node Fail 203 216 let err = serializer.write_node(&invalid_node).unwrap_err(); 204 217 match err { 205 218 crate::error::StarError::InvalidState(msg) => { 206 206 - assert!(msg.contains("Root node must contain entries") || msg.contains("Height 0 cannot be empty")); 207 207 - }, 219 219 + assert!( 220 220 + msg.contains("Root cannot be empty") 221 221 + || msg.contains("Height 0 cannot be empty"), 222 222 + "Got message: {}", 223 223 + msg 224 224 + ); 225 225 + } 208 226 e => panic!("Expected InvalidState, got {:?}", e), 209 227 } 210 228 }

+83 -155

src/validation.rs

reviewed

··· 1 1 use crate::error::{Result, StarError}; 2 2 - use crate::types::{calculate_height, StarCommit, StarMstNode}; 2 2 + use crate::types::{calculate_height, StarMstNode}; 3 3 4 4 - #[derive(Debug)] 5 5 - pub struct StarValidator { 6 6 - state: State, 7 7 - } 8 8 - 9 9 - #[derive(Debug)] 10 10 - enum State { 11 11 - Header, 12 12 - Body { stack: Vec<Expectation> }, 13 13 - Done, 14 14 - } 4 4 + /// Validates the structure of a STAR MST node. 5 5 + /// 6 6 + /// Checks: 7 7 + /// - Key height consistency (all keys must have same height) 8 8 + /// - Height matching against expectation 9 9 + /// - Structural rules (Height 0 vs >0 constraints) 10 10 + /// - Implicit/Explicit V rules 11 11 + /// 12 12 + /// Returns (height, reconstructed_keys) 13 13 + pub fn validate_node_structure( 14 14 + node: &StarMstNode, 15 15 + expected: Option<u32>, 16 16 + ) -> Result<(u32, Vec<Vec<u8>>)> { 17 17 + let mut node_height = None; 18 18 + let mut prev_key_bytes = Vec::new(); 19 19 + let mut entry_keys = Vec::new(); 15 20 16 16 - #[derive(Debug)] 17 17 - enum Expectation { 18 18 - Root, 19 19 - Node { height: u32 }, 20 20 - Record, 21 21 - } 21 21 + for e in &node.e { 22 22 + let mut key = if e.p as usize <= prev_key_bytes.len() { 23 23 + prev_key_bytes[..e.p as usize].to_vec() 24 24 + } else { 25 25 + prev_key_bytes.clone() 26 26 + }; 27 27 + key.extend_from_slice(&e.k); 22 28 23 23 - impl StarValidator { 24 24 - pub fn new() -> Self { 25 25 - Self { state: State::Header } 26 26 - } 29 29 + let h = calculate_height(&key); 27 30 28 28 - pub fn accept_header(&mut self, commit: &StarCommit) -> Result<()> { 29 29 - match &self.state { 30 30 - State::Header => { 31 31 - let stack = if commit.data.is_some() { 32 32 - vec![Expectation::Root] 33 33 - } else { 34 34 - Vec::new() // Empty tree 35 35 - }; 36 36 - self.state = State::Body { stack }; 37 37 - Ok(()) 38 38 - }, 39 39 - _ => Err(StarError::InvalidState("Header already written or invalid state".into())), 31 31 + if let Some(existing) = node_height { 32 32 + if h != existing { 33 33 + return Err(StarError::InvalidState(format!( 34 34 + "Inconsistent key height in node: {} vs {}", 35 35 + h, existing 36 36 + ))); 37 37 + } 38 38 + } else { 39 39 + node_height = Some(h); 40 40 } 41 41 - } 42 41 43 43 - pub fn accept_node(&mut self, node: &StarMstNode) -> Result<()> { 44 44 - match &mut self.state { 45 45 - State::Body { stack } => { 46 46 - if stack.is_empty() { 47 47 - return Err(StarError::InvalidState("Unexpected node: tree is complete".into())); 48 48 - } 49 49 - 50 50 - let expectation = stack.pop().unwrap(); 51 51 - let height = match expectation { 52 52 - Expectation::Record => { 53 53 - return Err(StarError::InvalidState("Expected record, got node".into())); 54 54 - }, 55 55 - Expectation::Root => { 56 56 - if node.e.is_empty() { 57 57 - return Err(StarError::InvalidState("Root node must contain entries".into())); 58 58 - } 59 59 - Self::validate_node_height(node, None)? 60 60 - }, 61 61 - Expectation::Node { height } => { 62 62 - Self::validate_node_height(node, Some(height))? 63 63 - } 64 64 - }; 65 65 - 66 66 - if height == 0 { 67 67 - if node.l.is_some() || node.l_archived.is_some() { 68 68 - return Err(StarError::InvalidState("Height 0 node cannot have left child".into())); 69 69 - } 70 70 - for e in &node.e { 71 71 - if e.t.is_some() || e.t_archived.is_some() { 72 72 - return Err(StarError::InvalidState("Height 0 entries cannot have subtrees".into())); 73 73 - } 74 74 - } 75 75 - } else { 76 76 - if node.e.is_empty() && node.l.is_none() { 77 77 - return Err(StarError::InvalidState("Empty intermediate node must have left child".into())); 78 78 - } 79 79 - } 80 80 - 81 81 - let child_height = if height > 0 { height - 1 } else { 0 }; 82 82 - 83 83 - for e in node.e.iter().rev() { 84 84 - if e.t_archived == Some(true) { 85 85 - stack.push(Expectation::Node { height: child_height }); 86 86 - } 87 87 - 88 88 - if e.v_archived == Some(true) { 89 89 - if height == 0 && e.v.is_some() { 90 90 - return Err(StarError::InvalidState("Height 0 node must omit record CIDs".into())); 91 91 - } 92 92 - if height > 0 && e.v.is_none() { 93 93 - return Err(StarError::InvalidState("Intermediate node must include record CIDs".into())); 94 94 - } 95 95 - stack.push(Expectation::Record); 96 96 - } 97 97 - } 98 98 - 99 99 - if node.l_archived == Some(true) { 100 100 - stack.push(Expectation::Node { height: child_height }); 101 101 - } 102 102 - 103 103 - Ok(()) 104 104 - }, 105 105 - _ => Err(StarError::InvalidState("Invalid state for node".into())), 106 106 - } 42 42 + entry_keys.push(key.clone()); 43 43 + prev_key_bytes = key; 107 44 } 108 45 109 109 - pub fn accept_record(&mut self, _bytes: &[u8]) -> Result<()> { 110 110 - match &mut self.state { 111 111 - State::Body { stack } => { 112 112 - if stack.is_empty() { 113 113 - return Err(StarError::InvalidState("Unexpected record: tree is complete".into())); 114 114 - } 115 115 - match stack.pop().unwrap() { 116 116 - Expectation::Record => Ok(()), 117 117 - _ => Err(StarError::InvalidState("Expected node, got record".into())), 118 118 - } 119 119 - }, 120 120 - _ => Err(StarError::InvalidState("Invalid state for record".into())), 46 46 + let height = match (node_height, expected) { 47 47 + (Some(h), Some(exp)) => { 48 48 + if h != exp { 49 49 + return Err(StarError::InvalidState(format!( 50 50 + "Height mismatch: found {}, expected {}", 51 51 + h, exp 52 52 + ))); 53 53 + } 54 54 + h 121 55 } 122 122 - } 56 56 + (Some(h), None) => h, 57 57 + (None, Some(exp)) => { 58 58 + if exp == 0 { 59 59 + return Err(StarError::InvalidState("Height 0 cannot be empty".into())); 60 60 + } 61 61 + exp 62 62 + } 63 63 + (None, None) => return Err(StarError::InvalidState("Root cannot be empty".into())), 64 64 + }; 123 65 124 124 - fn validate_node_height(node: &StarMstNode, expected: Option<u32>) -> Result<u32> { 125 125 - let mut node_height = None; 126 126 - let mut prev_key_bytes = Vec::new(); 127 127 - 66 66 + if height == 0 { 67 67 + if node.l.is_some() || node.l_archived.is_some() { 68 68 + return Err(StarError::InvalidState( 69 69 + "Height 0 node cannot have left child".into(), 70 70 + )); 71 71 + } 128 72 for e in &node.e { 129 129 - let mut key = if e.p as usize <= prev_key_bytes.len() { 130 130 - prev_key_bytes[..e.p as usize].to_vec() 131 131 - } else { 132 132 - prev_key_bytes.clone() 133 133 - }; 134 134 - key.extend_from_slice(&e.k); 135 135 - 136 136 - let h = calculate_height(&key); 137 137 - 138 138 - if let Some(existing) = node_height { 139 139 - if h != existing { 140 140 - return Err(StarError::InvalidState(format!("Inconsistent key height in node: {} vs {}", h, existing))); 141 141 - } 142 142 - } else { 143 143 - node_height = Some(h); 73 73 + if e.t.is_some() || e.t_archived.is_some() { 74 74 + return Err(StarError::InvalidState( 75 75 + "Height 0 entries cannot have subtrees".into(), 76 76 + )); 144 77 } 145 145 - prev_key_bytes = key; 78 78 + if e.v.is_some() { 79 79 + return Err(StarError::InvalidState( 80 80 + "Height 0 node must omit record CIDs".into(), 81 81 + )); 82 82 + } 83 83 + } 84 84 + } else { 85 85 + if node.e.is_empty() && node.l.is_none() { 86 86 + return Err(StarError::InvalidState( 87 87 + "Empty intermediate node must have left child".into(), 88 88 + )); 146 89 } 147 147 - 148 148 - let height = match (node_height, expected) { 149 149 - (Some(h), Some(exp)) => { 150 150 - if h != exp { 151 151 - return Err(StarError::InvalidState(format!("Height mismatch: found {}, expected {}", h, exp))); 152 152 - } 153 153 - h 154 154 - }, 155 155 - (Some(h), None) => h, 156 156 - (None, Some(exp)) => { 157 157 - if exp == 0 { return Err(StarError::InvalidState("Height 0 cannot be empty".into())); } 158 158 - exp 159 159 - }, 160 160 - (None, None) => return Err(StarError::InvalidState("Root cannot be empty".into())), 161 161 - }; 162 162 - Ok(height) 163 163 - } 164 164 - 165 165 - pub fn is_done(&self) -> bool { 166 166 - match &self.state { 167 167 - State::Body { stack } => stack.is_empty(), 168 168 - State::Done => true, // Not reachable with current logic but semantically true 169 169 - _ => false, 90 90 + for e in &node.e { 91 91 + if e.v.is_none() { 92 92 + return Err(StarError::InvalidState( 93 93 + "Intermediate node must include record CIDs".into(), 94 94 + )); 95 95 + } 170 96 } 171 97 } 98 98 + 99 99 + Ok((height, entry_keys)) 172 100 }