non-working tree hash

Zacholme7 · Zacholme7 · commit 72ff7fb2bda3 · 2025-04-16T17:18:32.000Z
diff --git a/anchor/common/ssv_types/src/message.rs b/anchor/common/ssv_types/src/message.rs
@@ -6,8 +6,8 @@ use std::{
 use ssz::{Decode, DecodeError, Encode};
 use ssz_derive::{Decode, Encode};
 use thiserror::Error;
-use tree_hash::{PackedEncoding, TreeHash, TreeHashType};
-use zerocopy::IntoBytes;
+use tree_hash::{merkle_root, mix_in_length, MerkleHasher, PackedEncoding, TreeHash, TreeHashType};
+use types::Hash256;
 
 use crate::{
     message::{
@@ -82,16 +82,17 @@ impl TreeHash for MsgType {
     }
 
     fn tree_hash_packed_encoding(&self) -> PackedEncoding {
-        todo!()
+        let value = self.clone() as u64;
+        value.tree_hash_packed_encoding()
     }
 
     fn tree_hash_packing_factor() -> usize {
-        1
+        u64::tree_hash_packing_factor()
     }
 
     fn tree_hash_root(&self) -> tree_hash::Hash256 {
-        let encoding = self.tree_hash_packed_encoding();
-        tree_hash::Hash256::from_slice(encoding.as_bytes())
+        let value = self.clone() as u64;
+        value.tree_hash_root()
     }
 }
 
@@ -181,19 +182,44 @@ pub struct SSVMessage {
 
 impl TreeHash for SSVMessage {
     fn tree_hash_type() -> TreeHashType {
-        todo!()
+        TreeHashType::Container
     }
 
     fn tree_hash_packed_encoding(&self) -> PackedEncoding {
-        todo!()
+        unreachable!("Container should not be packed")
     }
 
     fn tree_hash_packing_factor() -> usize {
-        todo!()
+        unreachable!("Container should not be packed")
     }
 
     fn tree_hash_root(&self) -> tree_hash::Hash256 {
-        todo!()
+        let mut hasher = MerkleHasher::with_leaves(3);
+
+        hasher
+            .write(self.msg_type.tree_hash_root().as_slice())
+            .unwrap();
+        hasher
+            .write(self.msg_id.tree_hash_root().as_slice())
+            .unwrap();
+        // Field 2: Data - variable-length byte array
+        // First get the data index
+        // Calculate chunks needed ((max_size + 31) / 32)
+        let chunks_needed = (722412 + 31) / 32;
+
+        // Merkleize the data with the calculated chunk count
+        let data_root = merkle_root(&self.data, chunks_needed);
+
+        // Mix in the length - this is equivalent to MerkleizeWithMixin in Go
+        let data_with_length = mix_in_length(&data_root, self.data.len());
+
+        // Add hashed data to the main tree
+        hasher
+            .write(data_with_length.as_slice())
+            .expect("Failed to write data");
+
+        // Finalize and return the root
+        hasher.finish().expect("Failed to finish hashing")
     }
 }
 
@@ -331,19 +357,91 @@ pub struct SignedSSVMessage {
 
 impl TreeHash for SignedSSVMessage {
     fn tree_hash_type() -> TreeHashType {
-        todo!()
+        TreeHashType::Container
     }
 
     fn tree_hash_packed_encoding(&self) -> PackedEncoding {
-        todo!()
+        unreachable!("Container should never be packed.")
     }
 
     fn tree_hash_packing_factor() -> usize {
-        todo!()
+        unreachable!("Container should never be packed.")
     }
 
-    fn tree_hash_root(&self) -> tree_hash::Hash256 {
-        todo!()
+    fn tree_hash_root(&self) -> Hash256 {
+        // Create hasher for 4 fields
+        let mut hasher = MerkleHasher::with_leaves(4);
+
+        let signatures_root = self.hash_signatures();
+        hasher
+            .write(signatures_root.as_slice())
+            .expect("Failed to write signatures");
+
+        let operator_ids_root = self.hash_operator_ids();
+        hasher
+            .write(operator_ids_root.as_slice())
+            .expect("Failed to write operator IDs");
+
+        hasher
+            .write(self.ssv_message.tree_hash_root().as_slice())
+            .expect("Failed to write SSV message");
+
+        let max_chunks = (8388836 + 31) / 32;
+        let full_data_root = merkle_root(&self.full_data, max_chunks);
+        let full_data_with_length = mix_in_length(&full_data_root, self.full_data.len());
+
+        hasher
+            .write(full_data_with_length.as_slice())
+            .expect("Failed to write full data");
+
+        // Finalize and return root hash
+        hasher.finish().expect("Failed to finish hashing")
+    }
+}
+
+// Helper methods to keep the main implementation cleaner
+impl SignedSSVMessage {
+    fn hash_signatures(&self) -> Hash256 {
+        // Create a hasher for the signatures list
+        let mut signatures_hasher = MerkleHasher::with_leaves(self.signatures.len());
+
+        // Hash each signature
+        for signature in &self.signatures {
+            // Each signature is a variable-length byte array with max 256 bytes
+            let signature_chunks = (256 + 31) / 32;
+            let signature_root = merkle_root(signature, signature_chunks);
+            let signature_with_length = mix_in_length(&signature_root, signature.len());
+
+            signatures_hasher
+                .write(signature_with_length.as_slice())
+                .expect("Failed to write signature");
+        }
+
+        // Get the signatures list root and mix in length
+        let root = signatures_hasher
+            .finish()
+            .expect("Failed to hash signatures");
+        mix_in_length(&root, self.signatures.len())
+    }
+
+    fn hash_operator_ids(&self) -> Hash256 {
+        // Create a hasher for the operator IDs list
+        let mut operators_hasher = MerkleHasher::with_leaves(self.operator_ids.len());
+
+        // Hash each operator ID
+        for operator_id in &self.operator_ids {
+            // Assuming OperatorId can be converted to u64
+            let id_value: u64 = operator_id.0;
+            operators_hasher
+                .write(id_value.tree_hash_root().as_slice())
+                .expect("Failed to write operator ID");
+        }
+
+        // Get the operator IDs list root and mix in length
+        let root = operators_hasher
+            .finish()
+            .expect("Failed to hash operator IDs");
+        mix_in_length(&root, self.operator_ids.len())
     }
 }
 
diff --git a/anchor/spec_tests/src/qbft/create_message.rs b/anchor/spec_tests/src/qbft/create_message.rs
@@ -1,10 +1,6 @@
-use std::{collections::VecDeque, sync::Arc};
-
 use openssl::pkey::{PKey, Private};
-use parking_lot::RwLock;
-use qbft::UnsignedWrappedQbftMessage;
 use serde::Deserialize;
-use ssv_types::{consensus::QbftMessageType, OperatorId, Round};
+use ssv_types::{consensus::QbftMessageType, IndexSet, OperatorId, Round};
 use types::Hash256;
 
 use super::{qbft_deserializers::*, SpecQbft};
@@ -19,15 +15,10 @@ impl SpecTest for CreateMessageTest {
     fn run(&self) -> bool {
         let spec_qbft = self.spec_qbft.as_ref().expect("Setup has been called");
         let key = self.signing_key.as_ref().expect("Setup has been called");
-        let msg_queue = self.msg_rx.as_ref().expect("Setup has been called").clone();
 
         // Create a new unsigned message. Have to create a new unsigned message to be received on
         // the queue and then perform signing
-        spec_qbft.create_message(self.create_type, self.root);
-        let unsigned_message = msg_queue
-            .write()
-            .pop_back()
-            .expect("Have already created the message");
+        let unsigned_message = spec_qbft.create_message(self.create_type, self.root);
         let signed_message = spec_qbft.sign(unsigned_message, key);
 
         // Compute the merkle root of the message and compare it to the expected_root
@@ -36,21 +27,22 @@ impl SpecTest for CreateMessageTest {
 
     // Setup the qbft instance for constructing a new message
     fn setup(&mut self) {
-        let four_key_set = TestKeySet::four_share_set();
+        let four_share_set = TestKeySet::four_share_set();
+        let committee: IndexSet<OperatorId> =
+            four_share_set.operator_keys.keys().cloned().collect();
 
         // All message creation testing code uses operator one as the message signer
-        let operator_one_private = four_key_set
+        let operator_one_private = four_share_set
             .operator_keys
             .get(&OperatorId::from(1))
             .expect("Exists");
         let operator_one_private =
             PKey::from_rsa(operator_one_private.to_owned()).expect("Valid key");
 
-        let (qbft, queue) = SpecQbft::new();
+        let qbft = SpecQbft::new(committee);
 
         // Complete the setup
         self.spec_qbft = Some(qbft);
-        self.msg_rx = Some(queue);
         self.signing_key = Some(operator_one_private);
     }
 
@@ -104,10 +96,6 @@ pub struct CreateMessageTest {
     #[serde(skip)]
     pub spec_qbft: Option<SpecQbft>,
 
-    // Unsigned message receiver
-    #[serde(skip)]
-    pub msg_rx: Option<Arc<RwLock<VecDeque<UnsignedWrappedQbftMessage>>>>,
-
     // The operator private key for message signing
     #[serde(skip)]
     pub signing_key: Option<PKey<Private>>,
diff --git a/anchor/spec_tests/src/qbft/mod.rs b/anchor/spec_tests/src/qbft/mod.rs
@@ -23,7 +23,7 @@ use ssv_types::{
     consensus::{BeaconVote, QbftMessageType},
     message::SignedSSVMessage,
     msgid::MessageId,
-    OperatorId, Round,
+    IndexSet, OperatorId, Round,
 };
 use ssz::Encode;
 pub use timeout::TimeoutTest;
@@ -39,15 +39,14 @@ pub type ExplicitSendFn = Arc<RwLock<VecDeque<UnsignedWrappedQbftMessage>>>;
 pub struct SpecQbft(pub ExplicitQbft);
 impl SpecQbft {
     // Construct a wrapped qbft instance
-    pub fn new() -> (Self, ExplicitSendFn) {
-        let config: Config<DefaultLeaderFunction> = ConfigBuilder::new(
-            1.into(),
-            InstanceHeight::default(),
-            (1..=4).map(OperatorId::from).collect(),
-        )
-        .build()
-        .unwrap();
-
+    pub fn new(committee: IndexSet<OperatorId>) -> Self {
+        let config: Config<DefaultLeaderFunction> =
+            ConfigBuilder::new(1.into(), InstanceHeight::default(), committee)
+                .build()
+                .unwrap();
+
+        // Todo!(). For creation tests, start data does not matter since we are not testing
+        // consensus. Adjust for consensus tests
         let data = BeaconVote {
             block_root: Hash256::random(),
             source: types::Checkpoint::default(),
@@ -57,18 +56,23 @@ impl SpecQbft {
         let msg_queue = Arc::new(RwLock::new(VecDeque::new()));
         let msg_queue_clone = msg_queue.clone();
 
-        let message_handler: QbftSendFn =
-            Box::new(move |message| msg_queue_clone.write().push_back(message));
+        let message_handler: QbftSendFn = Box::new(move |message| {
+            msg_queue_clone.write().push_back(message);
+        });
 
         let qbft = Qbft::new(config, data, MessageId::from([0; 56]), message_handler);
 
-        (SpecQbft(qbft), msg_queue)
+        SpecQbft(qbft)
     }
 
     // Create a new UnsignedSSVMessage. Will be send to the queue registered with the qbft instance
-    pub fn create_message(&self, message_type: QbftMessageType, data_hash: Hash256) {
+    pub fn create_message(
+        &self,
+        message_type: QbftMessageType,
+        data_hash: Hash256,
+    ) -> UnsignedWrappedQbftMessage {
         self.0
-            .new_unsigned_message_spec(message_type, data_hash, vec![], vec![]);
+            .new_unsigned_message_spec(message_type, data_hash, vec![], vec![])
     }
 
     // In favor of not having to construct an entire NetworkMessageSender, just copy the signing
@@ -96,8 +100,7 @@ impl SpecQbft {
 
     // Confirm that merkle root of signed message equals the expected root
     pub fn verify_root(&self, msg: SignedSSVMessage, root: Hash256) -> bool {
-        let spec_message: qbft_spec_types::SpecSignedSSVMessage = msg.into();
-        spec_message.tree_hash_root() == root
+        msg.tree_hash_root() == root
     }
 }
 
