justification parsing

Author: Zacholme7

Diff for: Cargo.lock

@@ -885,6 +885,7 @@ where
             round_change_justification,
             prepare_justification,
         };
+        println!("{:?}", qbft_message);
 
         let ssv_message = SSVMessage::new(
             MsgType::SSVConsensusMsgType,

Diff for: anchor/common/qbft/src/lib.rs

@@ -14,6 +14,7 @@ indexmap = { workspace = true }
 openssl = { workspace = true }
 rusqlite = { workspace = true }
 serde = { workspace = true }
+serde_json = { workspace = true }
 sha2 = { workspace = true }
 thiserror = { workspace = true }
 tree_hash = { workspace = true }

Diff for: anchor/common/ssv_types/Cargo.toml

@@ -3,6 +3,9 @@ use std::{
     fmt::{Debug, Formatter},
 };
 
+use base64::prelude::*;
+use serde::{de::Error, Deserialize, Deserializer};
+use serde_json::Value;
 use ssz::{Decode, DecodeError, Encode};
 use ssz_derive::{Decode, Encode};
 use thiserror::Error;
@@ -76,6 +79,23 @@ pub enum MsgType {
     SSVPartialSignatureMsgType = 1,
 }
 
+impl<'de> Deserialize<'de> for MsgType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let value = u64::deserialize(deserializer)?;
+        match value {
+            0 => Ok(MsgType::SSVConsensusMsgType),
+            1 => Ok(MsgType::SSVPartialSignatureMsgType),
+            _ => Err(serde::de::Error::custom(format!(
+                "Invalid MsgType value: {}",
+                value
+            ))),
+        }
+    }
+}
+
 impl TreeHash for MsgType {
     fn tree_hash_type() -> TreeHashType {
         TreeHashType::Basic
@@ -173,11 +193,17 @@ pub enum SSVMessageError {
 }
 
 /// Represents a bare SSVMessage with a type, ID, and data.
-#[derive(Encode, Decode, Clone, PartialEq, Eq)]
+#[derive(Encode, Decode, Clone, PartialEq, Eq, Deserialize)]
 pub struct SSVMessage {
+    #[serde(rename = "MsgType")]
     msg_type: MsgType,
-    msg_id: MessageId, // Fixed-size [u8; 56]
-    data: Vec<u8>,     // Variable-length byte array
+
+    #[serde(rename = "MsgID")]
+    msg_id: MessageId,
+
+    #[serde(rename = "Data")]
+    #[serde(deserialize_with = "deserialize_base64_or_empty")]
+    data: Vec<u8>,
 }
 
 impl TreeHash for SSVMessage {
@@ -202,23 +228,16 @@ impl TreeHash for SSVMessage {
         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");
+        hasher.write(data_with_length.as_slice()).unwrap();
 
-        // Finalize and return the root
         hasher.finish().expect("Failed to finish hashing")
     }
 }
@@ -347,12 +366,51 @@ pub enum SignedSSVMessageError {
 
 /// Represents a signed SSV Message with signatures, operator IDs, the message itself, and full
 /// data.
-#[derive(Encode, Decode, Clone, PartialEq, Eq)]
+#[derive(Encode, Decode, Clone, PartialEq, Eq, Deserialize)]
 pub struct SignedSSVMessage {
-    signatures: Vec<Vec<u8>>, // Vec of Vec<u8>, max 13 elements, each with 256 bytes
-    operator_ids: Vec<OperatorId>, // Vec of OperatorID (u64), max 13 elements
-    ssv_message: SSVMessage,  // SSVMessage: Required field
-    full_data: Vec<u8>,       // Variable-length byte array, max 4,194,532 bytes
+    #[serde(rename = "Signatures")]
+    #[serde(deserialize_with = "deserialize_base64_vec")]
+    signatures: Vec<Vec<u8>>,
+
+    #[serde(rename = "OperatorIDs")]
+    operator_ids: Vec<OperatorId>,
+
+    #[serde(rename = "SSVMessage")]
+    ssv_message: SSVMessage,
+
+    #[serde(rename = "FullData")]
+    #[serde(deserialize_with = "deserialize_base64_or_empty")]
+    full_data: Vec<u8>,
+}
+
+fn deserialize_base64_or_empty<'de, D>(deserializer: D) -> Result<Vec<u8>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    let value = Value::deserialize(deserializer)?;
+
+    match value {
+        Value::Null => Ok(Vec::new()), // Return empty Vec for null values
+        Value::String(s) => BASE64_STANDARD
+            .decode(s.as_bytes())
+            .map_err(D::Error::custom),
+        _ => Err(D::Error::custom("Expected null or a base64 string")),
+    }
+}
+
+fn deserialize_base64_vec<'de, D>(deserializer: D) -> Result<Vec<Vec<u8>>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    let string_vec: Vec<String> = serde::Deserialize::deserialize(deserializer)?;
+    string_vec
+        .into_iter()
+        .map(|s| {
+            BASE64_STANDARD
+                .decode(s.as_bytes())
+                .map_err(serde::de::Error::custom)
+        })
+        .collect()
 }
 
 impl TreeHash for SignedSSVMessage {

Diff for: anchor/common/ssv_types/src/message.rs

@@ -1,6 +1,7 @@
 use std::fmt::{Debug, Formatter};
 
 use derive_more::{Display, From, Into};
+use serde::{Deserialize, Deserializer};
 use ssz::{Decode, DecodeError, Encode};
 use tree_hash::{PackedEncoding, TreeHash, TreeHashType};
 use types::{typenum::U56, PublicKeyBytes, VariableList};
@@ -85,6 +86,23 @@ impl TreeHash for MessageId {
     }
 }
 
+impl<'de> Deserialize<'de> for MessageId {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        // First deserialize as a Vec<u8>
+        let vec = Vec::<u8>::deserialize(deserializer)?;
+
+        // Then try to convert to [u8; 56]
+        vec.try_into()
+            .map(MessageId)
+            .map_err(|_| serde::de::Error::custom("Expected array of 56 bytes".to_string()))
+    }
+}
+
+// Implement custom deserialization for MessageId
+
 impl Debug for MessageId {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}", hex::encode(self.0))
@@ -108,6 +126,16 @@ impl MessageId {
         MessageId(id)
     }
 
+    // todo!() remove or gate this
+    pub fn for_spectest() -> Self {
+        let mut id = [0; 56];
+        id[0] = 1;
+        id[1] = 2;
+        id[2] = 3;
+        id[6] = 4;
+        MessageId(id)
+    }
+
     pub fn domain(&self) -> DomainType {
         DomainType(
             self.0[0..4]

Diff for: anchor/common/ssv_types/src/msgid.rs

@@ -2,14 +2,28 @@ use std::{cmp::Eq, fmt::Debug, hash::Hash};
 
 use derive_more::{Deref, From};
 use openssl::{pkey::Public, rsa::Rsa};
+use serde::Deserialize;
 use ssz_derive::{Decode, Encode};
 use types::Address;
 
 use crate::util::parse_rsa;
 
 /// Unique identifier for an Operator.
 #[derive(
-    Clone, Copy, Debug, Default, Eq, PartialEq, Hash, From, Deref, Encode, Decode, Ord, PartialOrd,
+    Clone,
+    Copy,
+    Debug,
+    Default,
+    Eq,
+    PartialEq,
+    Hash,
+    From,
+    Deref,
+    Encode,
+    Decode,
+    Ord,
+    PartialOrd,
+    Deserialize,
 )]
 #[ssz(struct_behaviour = "transparent")]
 pub struct OperatorId(pub u64);

Diff for: anchor/common/ssv_types/src/operator.rs

@@ -1,10 +1,10 @@
 use openssl::pkey::{PKey, Private};
 use serde::Deserialize;
-use ssv_types::{consensus::QbftMessageType, IndexSet, OperatorId, Round};
+use ssv_types::{consensus::QbftMessageType, msgid::MessageId, IndexSet, OperatorId, Round};
 use types::Hash256;
 
 use super::{qbft_deserializers::*, SpecQbft};
-use crate::{utils::TestKeySet, QbftSpecTestType, SpecTest, SpecTestType};
+use crate::{qbft::SignedSSVMessage, utils::TestKeySet, QbftSpecTestType, SpecTest, SpecTestType};
 
 impl SpecTest for CreateMessageTest {
     fn name(&self) -> &str {
@@ -15,14 +15,33 @@ 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 prepare_justifications = if let Some(prepare) = &self.prepare_justifications {
+            prepare.clone()
+        } else {
+            Vec::new()
+        };
+
+        let round_change_justifications =
+            if let Some(round_change) = &self.round_change_justifications {
+                round_change.clone()
+            } else {
+                Vec::new()
+            };
 
         // Create a new unsigned message. Have to create a new unsigned message to be received on
         // the queue and then perform signing
-        let unsigned_message = spec_qbft.create_message(self.create_type, self.root);
+        let unsigned_message = spec_qbft.create_message(
+            self.create_type,
+            self.root,
+            round_change_justifications,
+            prepare_justifications,
+        );
         let signed_message = spec_qbft.sign(unsigned_message, key);
 
         // Compute the merkle root of the message and compare it to the expected_root
         spec_qbft.verify_root(signed_message, self.expected_root)
+
+        // If there are justifications, verify those.. todo!()
     }
 
     // Setup the qbft instance for constructing a new message
@@ -31,6 +50,9 @@ impl SpecTest for CreateMessageTest {
         let committee: IndexSet<OperatorId> =
             four_share_set.operator_keys.keys().cloned().collect();
 
+        // All test identifiers are [1,2,3,4]
+        let identifier = MessageId::for_spectest();
+
         // All message creation testing code uses operator one as the message signer
         let operator_one_private = four_share_set
             .operator_keys
@@ -39,7 +61,7 @@ impl SpecTest for CreateMessageTest {
         let operator_one_private =
             PKey::from_rsa(operator_one_private.to_owned()).expect("Valid key");
 
-        let qbft = SpecQbft::new(committee);
+        let qbft = SpecQbft::new(committee, identifier);
 
         // Complete the setup
         self.spec_qbft = Some(qbft);
@@ -71,11 +93,11 @@ pub struct CreateMessageTest {
 
     // Any round change justifications for the message
     #[serde(rename = "RoundChangeJustifications")]
-    pub round_change_justifications: Option<Vec<Justification>>,
+    pub round_change_justifications: Option<Vec<SignedSSVMessage>>,
 
     // Any prepare justifications for the message
     #[serde(rename = "PrepareJustifications")]
-    pub prepare_justifications: Option<Vec<Justification>>,
+    pub prepare_justifications: Option<Vec<SignedSSVMessage>>,
 
     // The type of the QBFT Message to create
     #[serde(
@@ -100,25 +122,3 @@ pub struct CreateMessageTest {
     #[serde(skip)]
     pub signing_key: Option<PKey<Private>>,
 }
-
-#[derive(Debug, Deserialize)]
-pub struct Justification {
-    #[serde(rename = "Signatures")]
-    pub signatures: Vec<String>,
-    #[serde(rename = "OperatorIDs")]
-    pub operator_ids: Vec<u64>,
-    #[serde(rename = "SSVMessage")]
-    pub ssv_message: SsvMessage,
-    #[serde(rename = "FullData")]
-    pub full_data: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-pub struct SsvMessage {
-    #[serde(rename = "MsgType")]
-    pub msg_type: u8,
-    #[serde(rename = "MsgID")]
-    pub msg_id: Vec<u8>,
-    #[serde(rename = "Data")]
-    pub data: String,
-}