From 5dbab01534ae987140eb11d81e5d82e90f6fdbc2 Mon Sep 17 00:00:00 2001 From: Peter Zhang Date: Mon, 8 Sep 2025 15:19:41 +0800 Subject: [PATCH] simplify --- common/append_merkle/src/merkle_tree.rs | 44 +++++++++-------------- common/append_merkle/src/sha3.rs | 10 ++++-- node/storage/src/log_store/log_manager.rs | 16 +++------ node/storage/src/log_store/tests.rs | 19 ++-------- 4 files changed, 31 insertions(+), 58 deletions(-) diff --git a/common/append_merkle/src/merkle_tree.rs b/common/append_merkle/src/merkle_tree.rs index 9ed93fd..c694263 100644 --- a/common/append_merkle/src/merkle_tree.rs +++ b/common/append_merkle/src/merkle_tree.rs @@ -47,7 +47,7 @@ impl OptionalHash { /// Convert a Proof to Proof pub fn convert_proof_to_h256(proof: Proof) -> Result, anyhow::Error> { - let lemma: Vec = proof + let lemma = proof .lemma() .iter() .map(|oh| oh.to_h256_or_zero()) @@ -60,7 +60,7 @@ impl OptionalHash { pub fn convert_proof_from_h256( proof: Proof, ) -> Result, anyhow::Error> { - let lemma: Vec = proof + let lemma = proof .lemma() .iter() .map(|h| OptionalHash::some(*h)) @@ -101,9 +101,10 @@ impl From for Option { impl AsRef<[u8]> for OptionalHash { fn as_ref(&self) -> &[u8] { + static ZERO_BYTES: [u8; 32] = [0u8; 32]; match &self.0 { Some(hash) => hash.as_ref(), - None => &[0u8; 32], // Return zeros for null hash + None => &ZERO_BYTES, // Return reference to static zeros for null hash } } } @@ -123,24 +124,17 @@ impl Encode for OptionalHash { } fn ssz_fixed_len() -> usize { - 33 // 1 byte for Some/None + 32 bytes for hash + 32 // Same as H256 - just 32 bytes, no flag byte } fn ssz_bytes_len(&self) -> usize { - 33 + 32 } fn ssz_append(&self, buf: &mut Vec) { - match &self.0 { - Some(hash) => { - buf.push(1); // Some discriminant - hash.ssz_append(buf); - } - None => { - buf.push(0); // None discriminant - buf.extend_from_slice(&[0u8; 32]); - } - } + // Use H256::zero() for None, actual hash for Some + let hash = self.0.unwrap_or_else(H256::zero); + hash.ssz_append(buf); } } @@ -150,27 +144,21 @@ impl Decode for OptionalHash { } fn ssz_fixed_len() -> usize { - 33 + 32 // Same as H256 } fn from_ssz_bytes(bytes: &[u8]) -> Result { - if bytes.len() != 33 { + if bytes.len() != 32 { return Err(ssz::DecodeError::InvalidByteLength { len: bytes.len(), - expected: 33, + expected: 32, }); } - match bytes[0] { - 0 => Ok(OptionalHash::none()), - 1 => { - let hash = H256::from_ssz_bytes(&bytes[1..])?; - Ok(OptionalHash::some(hash)) - } - _ => Err(ssz::DecodeError::BytesInvalid( - "Invalid discriminant for OptionalHash".to_string(), - )), - } + let hash = H256::from_ssz_bytes(bytes)?; + // If it's H256::zero(), treat it as None, otherwise Some + + Ok(OptionalHash::some(hash)) } } diff --git a/common/append_merkle/src/sha3.rs b/common/append_merkle/src/sha3.rs index f5d38b7..0a97e22 100644 --- a/common/append_merkle/src/sha3.rs +++ b/common/append_merkle/src/sha3.rs @@ -54,12 +54,18 @@ impl Algorithm for Sha3Algorithm { impl Algorithm for Sha3Algorithm { fn parent(left: &OptionalHash, right: &OptionalHash) -> OptionalHash { match (&left.0, &right.0) { - (Some(l), Some(r)) => OptionalHash::some(Self::parent(l, r)), + (Some(l), Some(r)) => { + // Use the H256 implementation directly to ensure identical logic + let result = >::parent(l, r); + OptionalHash::some(result) + } _ => OptionalHash::none(), } } fn leaf(data: &[u8]) -> OptionalHash { - OptionalHash::some(Self::leaf(data)) + // Use the H256 implementation directly to ensure identical logic + let result = >::leaf(data); + OptionalHash::some(result) } } diff --git a/node/storage/src/log_store/log_manager.rs b/node/storage/src/log_store/log_manager.rs index f87aa56..b0d3fad 100644 --- a/node/storage/src/log_store/log_manager.rs +++ b/node/storage/src/log_store/log_manager.rs @@ -57,9 +57,8 @@ const PAD_MAX_SIZE: usize = 1 << 20; static PAD_SEGMENT_ROOT: Lazy = Lazy::new(|| { let h256_leaves = data_to_merkle_leaves(&[0; ENTRY_SIZE * PORA_CHUNK_SIZE]).unwrap(); - let optional_leaves: Vec = - h256_leaves.into_iter().map(OptionalHash::from).collect(); - Merkle::new(optional_leaves, 0, None).root() + + Merkle::new(h256_leaves, 0, None).root() }); pub struct UpdateFlowMessage { pub pad_data: usize, @@ -1015,10 +1014,7 @@ impl LogManager { let mut completed_chunk_index = None; if pad_data.len() < last_chunk_pad { is_full_empty = false; - let pad_leaves: Vec = data_to_merkle_leaves(&pad_data)? - .into_iter() - .map(OptionalHash::from) - .collect(); + let pad_leaves = data_to_merkle_leaves(&pad_data)?; merkle.last_chunk_merkle.append_list(pad_leaves); merkle .pora_chunks_merkle @@ -1027,11 +1023,7 @@ impl LogManager { if last_chunk_pad != 0 { is_full_empty = false; // Pad the last chunk. - let last_chunk_leaves: Vec = - data_to_merkle_leaves(&pad_data[..last_chunk_pad])? - .into_iter() - .map(OptionalHash::from) - .collect(); + let last_chunk_leaves = data_to_merkle_leaves(&pad_data[..last_chunk_pad])?; merkle.last_chunk_merkle.append_list(last_chunk_leaves); merkle .pora_chunks_merkle diff --git a/node/storage/src/log_store/tests.rs b/node/storage/src/log_store/tests.rs index f3f8e0c..dfafec0 100644 --- a/node/storage/src/log_store/tests.rs +++ b/node/storage/src/log_store/tests.rs @@ -27,20 +27,11 @@ fn test_put_get() { 0, None, ); - let padding_leaves: Vec = - data_to_merkle_leaves(&LogManager::padding_raw(start_offset - 1)) - .unwrap() - .into_iter() - .map(OptionalHash::from) - .collect(); + let padding_leaves = data_to_merkle_leaves(&LogManager::padding_raw(start_offset - 1)).unwrap(); merkle.append_list(padding_leaves); let mut data_padded = data.clone(); data_padded.append(&mut vec![0u8; CHUNK_SIZE]); - let data_leaves: Vec = data_to_merkle_leaves(&data_padded) - .unwrap() - .into_iter() - .map(OptionalHash::from) - .collect(); + let data_leaves = data_to_merkle_leaves(&data_padded).unwrap(); merkle.append_list(data_leaves); merkle.commit(Some(0)); let tx_merkle = sub_merkle_tree(&data).unwrap(); @@ -144,11 +135,7 @@ fn test_root() { let mt = sub_merkle_tree(&data).unwrap(); println!("{:?} {}", mt.root(), hex::encode(mt.root())); let append_mt = AppendMerkleTree::::new( - data_to_merkle_leaves(&data) - .unwrap() - .into_iter() - .map(OptionalHash::from) - .collect(), + data_to_merkle_leaves(&data).unwrap(), 0, None, );