fix: compile errors in tests, thread child_level through DecryptionStream, fix stale docstring

- Fix invalid `xor_name::crate::hash::content_hash` syntax in src/tests.rs
  (write_and_read and seek_over_chunk_limit) — should be `crate::hash::`
- Thread child_level through DecryptionStream instead of hardcoding 0,
  so streaming decrypt uses the correct KDF domain separation
- Fix Python docstring that still said "SHA256" instead of "BLAKE3"

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: mickvandijke

src/python.rs

@@ -246,7 +246,7 @@ impl PyEncryptedChunk {
     /// Get the hash of the encrypted chunk.
     ///
     /// Returns:
-    ///     bytes: The SHA256 hash of the encrypted chunk.
+    ///     bytes: The BLAKE3 hash of the encrypted chunk.
     pub fn hash(&self) -> Cow<'_, [u8]> {
         crate::hash::content_hash(&self.inner.content)
             .0

src/stream_decrypt.rs

@@ -28,6 +28,7 @@ use xor_name::XorName;
 pub struct DecryptionStream<F> {
     chunk_infos: Vec<ChunkInfo>,
     src_hashes: Vec<XorName>,
+    child_level: usize,
     get_chunk_parallel: F,
     current_batch_start: usize,
     current_batch_chunks: Vec<Bytes>,
@@ -51,13 +52,15 @@ where
             data_map.clone()
         };
 
+        let child_level = root_map.child().unwrap_or(0);
         let mut chunk_infos = root_map.infos().to_vec();
         chunk_infos.sort_by_key(|info| info.index);
         let src_hashes = extract_hashes(&root_map);
 
         Ok(Self {
             chunk_infos,
             src_hashes,
+            child_level,
             get_chunk_parallel,
             current_batch_start: 0,
             current_batch_chunks: Vec::new(),
@@ -100,8 +103,12 @@ where
         for (info, (_index, encrypted_content)) in
             batch_infos.iter().zip(fetched_chunks.into_iter())
         {
-            let decrypted_chunk =
-                decrypt_chunk(info.index, &encrypted_content, &self.src_hashes, 0)?;
+            let decrypted_chunk = decrypt_chunk(
+                info.index,
+                &encrypted_content,
+                &self.src_hashes,
+                self.child_level,
+            )?;
             self.current_batch_chunks.push(decrypted_chunk);
         }
 
@@ -213,7 +220,12 @@ where
         let mut all_bytes = Vec::new();
         for chunk_index in start_chunk..=end_chunk {
             if let Some(encrypted_content) = chunk_map.get(&chunk_index) {
-                let decrypted = decrypt_chunk(chunk_index, encrypted_content, &self.src_hashes, 0)?;
+                let decrypted = decrypt_chunk(
+                    chunk_index,
+                    encrypted_content,
+                    &self.src_hashes,
+                    self.child_level,
+                )?;
                 all_bytes.extend_from_slice(&decrypted);
             }
         }
@@ -962,6 +974,7 @@ mod tests {
         let mock_stream = DecryptionStream {
             chunk_infos: data_map.infos().to_vec(),
             src_hashes: vec![crate::hash::content_hash(&[0u8]); num_chunks], // Dummy hashes
+            child_level: 0,
             get_chunk_parallel,
             current_batch_start: 0,
             current_batch_chunks: Vec::new(),

src/tests.rs

@@ -7,7 +7,7 @@
 // permissions and limitations relating to use of the SAFE Network Software.
 
 use crate::{
-    decrypt_full_set, decrypt_range, encrypt, get_chunk_size, get_num_chunks, 
+    decrypt_full_set, decrypt_range, encrypt, get_chunk_size, get_num_chunks,
     test_helpers::random_bytes, DataMap, EncryptedChunk, Error, StreamSelfDecryptor,
     StreamSelfEncryptor, MIN_ENCRYPTABLE_BYTES,
 };
@@ -20,17 +20,17 @@ fn test_stream_self_encryptor() {
     // Create a temporary directory for our test files
     let dir = tempdir().unwrap();
     println!("Created temp dir at: {:?}", dir.path());
-    
+
     // Create input file path and write test data
     let file_path = dir.path().join("input_file");
     let file_size = 10 * 1024 * 1024; // 10MB
     let data = random_bytes(file_size);
-    
+
     // Create parent directory if it doesn't exist
     if let Some(parent) = file_path.parent() {
         std::fs::create_dir_all(parent).unwrap();
     }
-    
+
     std::fs::write(&file_path, &data).unwrap();
     println!("Written test data to: {:?}", file_path);
 
@@ -44,14 +44,12 @@ fn test_stream_self_encryptor() {
     assert!(file_path.exists(), "Input file does not exist");
 
     // Encrypt the file using StreamSelfEncryptor
-    let mut encryptor = StreamSelfEncryptor::encrypt_from_file(
-        file_path, 
-        Some(chunk_path)
-    ).unwrap();
-    
+    let mut encryptor =
+        StreamSelfEncryptor::encrypt_from_file(file_path, Some(chunk_path)).unwrap();
+
     let mut encrypted_chunks = Vec::new();
     let mut data_map = None;
-    
+
     while let Ok((chunk, map)) = encryptor.next_encryption() {
         if let Some(c) = chunk {
             encrypted_chunks.push(c);
@@ -61,22 +59,20 @@ fn test_stream_self_encryptor() {
             break;
         }
     }
-    
+
     let data_map = data_map.expect("Encryption should produce a data map");
 
     // Create output file path for decryption
     let decrypted_file_path = dir.path().join("decrypted_file");
-    
+
     // Create parent directory for output file if it doesn't exist
     if let Some(parent) = decrypted_file_path.parent() {
         std::fs::create_dir_all(parent).unwrap();
     }
 
     // Initialize decryptor
-    let mut decryptor = StreamSelfDecryptor::decrypt_to_file(
-        decrypted_file_path.clone(), 
-        &data_map
-    ).unwrap();
+    let mut decryptor =
+        StreamSelfDecryptor::decrypt_to_file(decrypted_file_path.clone(), &data_map).unwrap();
 
     // Process all chunks
     for chunk in encrypted_chunks {
@@ -88,7 +84,11 @@ fn test_stream_self_encryptor() {
 
     // Verify the decrypted content matches original
     let decrypted_data = std::fs::read(&decrypted_file_path).unwrap();
-    assert_eq!(data.to_vec(), decrypted_data, "Decrypted data should match original");
+    assert_eq!(
+        data.to_vec(),
+        decrypted_data,
+        "Decrypted data should match original"
+    );
 }
 
 #[test]
@@ -102,7 +102,7 @@ fn write_and_read() -> Result<(), Error> {
 
     let chunk_hashes: Vec<_> = encrypted_chunks
         .iter()
-        .map(|chunk| xor_name::crate::hash::content_hash(&chunk.content))
+        .map(|chunk| crate::hash::content_hash(&chunk.content))
         .collect();
     dbg!(&chunk_hashes);
 
@@ -236,7 +236,7 @@ fn seek_over_chunk_limit() -> Result<(), Error> {
             get_root_data_map(data_map.clone(), &mut |hash| {
                 encrypted_chunks
                     .iter()
-                    .find(|chunk| xor_name::crate::hash::content_hash(&chunk.content) == hash)
+                    .find(|chunk| crate::hash::content_hash(&chunk.content) == hash)
                     .map(|chunk| chunk.content.clone())
                     .ok_or_else(|| Error::Generic(format!("Chunk not found for hash: {:?}", hash)))
             })?