test: add "ssz" spec-test runner

Author: MegaRedHand

Cargo.lock

@@ -25,3 +25,10 @@ libssz-types.workspace = true
 serde_json.workspace = true
 serde_yaml_ng.workspace = true
 rand.workspace = true
+
+datatest-stable = "0.3.3"
+
+[[test]]
+name = "ssz_spectests"
+path = "tests/ssz_spectests.rs"
+harness = false

crates/common/types/Cargo.toml

@@ -35,7 +35,7 @@ pub struct AttestationData {
 }
 
 /// Validator attestation bundled with its signature.
-#[derive(Debug, Clone, SszEncode, SszDecode)]
+#[derive(Debug, Clone, SszEncode, SszDecode, HashTreeRoot)]
 pub struct SignedAttestation {
     /// The index of the validator making the attestation.
     pub validator_id: u64,
@@ -79,7 +79,7 @@ pub fn validator_indices(bits: &AggregationBits) -> impl Iterator<Item = u64> +
 }
 
 /// Aggregated attestation with its signature proof, used for gossip on the aggregation topic.
-#[derive(Debug, Clone, SszEncode, SszDecode)]
+#[derive(Debug, Clone, SszEncode, SszDecode, HashTreeRoot)]
 pub struct SignedAggregatedAttestation {
     pub data: AttestationData,
     pub proof: AggregatedSignatureProof,

crates/common/types/src/attestation.rs

@@ -12,7 +12,7 @@ use crate::{
 use primitives::HashTreeRoot as _;
 
 /// Envelope carrying a block and its aggregated signatures.
-#[derive(Clone, SszEncode, SszDecode)]
+#[derive(Clone, SszEncode, SszDecode, HashTreeRoot)]
 pub struct SignedBlock {
     /// The block being signed.
     pub message: Block,
@@ -35,7 +35,7 @@ impl core::fmt::Debug for SignedBlock {
 }
 
 /// Signature payload for the block.
-#[derive(Clone, SszEncode, SszDecode)]
+#[derive(Clone, SszEncode, SszDecode, HashTreeRoot)]
 pub struct BlockSignatures {
     /// Attestation signatures for the aggregated attestations in the block body.
     ///
@@ -69,7 +69,7 @@ pub type AttestationSignatures = SszList<AggregatedSignatureProof, 4096>;
 /// The proof can verify that all participants signed the same message in the
 /// same epoch, using a single verification operation instead of checking
 /// each signature individually.
-#[derive(Debug, Clone, SszEncode, SszDecode)]
+#[derive(Debug, Clone, SszEncode, SszDecode, HashTreeRoot)]
 pub struct AggregatedSignatureProof {
     /// Bitfield indicating which validators' signatures are included.
     pub participants: AggregationBits,

crates/common/types/src/block.rs

@@ -0,0 +1,151 @@
+use std::path::Path;
+
+use ethlambda_types::primitives::HashTreeRoot;
+
+mod ssz_types;
+use ssz_types::{SszTestCase, SszTestVector, decode_hex, decode_hex_h256};
+
+const SUPPORTED_FIXTURE_FORMAT: &str = "ssz";
+
+fn run(path: &Path) -> datatest_stable::Result<()> {
+    let tests = SszTestVector::from_file(path)?;
+
+    for (name, test) in tests.tests {
+        if test.info.fixture_format != SUPPORTED_FIXTURE_FORMAT {
+            return Err(format!(
+                "Unsupported fixture format: {} (expected {})",
+                test.info.fixture_format, SUPPORTED_FIXTURE_FORMAT
+            )
+            .into());
+        }
+
+        println!("Running SSZ test: {name}");
+        run_ssz_test(&test)?;
+    }
+    Ok(())
+}
+
+fn run_ssz_test(test: &SszTestCase) -> datatest_stable::Result<()> {
+    match test.type_name.as_str() {
+        // Consensus containers
+        "Config" => run_typed_test::<ssz_types::Config, ethlambda_types::state::ChainConfig>(test),
+        "Checkpoint" => {
+            run_typed_test::<ssz_types::Checkpoint, ethlambda_types::checkpoint::Checkpoint>(test)
+        }
+        "BlockHeader" => {
+            run_typed_test::<ssz_types::BlockHeader, ethlambda_types::block::BlockHeader>(test)
+        }
+        "Validator" => {
+            run_typed_test::<ssz_types::Validator, ethlambda_types::state::Validator>(test)
+        }
+        "AttestationData" => run_typed_test::<
+            ssz_types::AttestationData,
+            ethlambda_types::attestation::AttestationData,
+        >(test),
+        "Attestation" => run_typed_test::<
+            ssz_types::Attestation,
+            ethlambda_types::attestation::Attestation,
+        >(test),
+        "AggregatedAttestation" => run_typed_test::<
+            ssz_types::AggregatedAttestation,
+            ethlambda_types::attestation::AggregatedAttestation,
+        >(test),
+        "BlockBody" => {
+            run_typed_test::<ssz_types::BlockBody, ethlambda_types::block::BlockBody>(test)
+        }
+        "Block" => run_typed_test::<ssz_types::Block, ethlambda_types::block::Block>(test),
+        "State" => run_typed_test::<ssz_types::TestState, ethlambda_types::state::State>(test),
+        "SignedAttestation" => run_typed_test::<
+            ssz_types::SignedAttestation,
+            ethlambda_types::attestation::SignedAttestation,
+        >(test),
+        "SignedBlock" => {
+            run_typed_test::<ssz_types::SignedBlock, ethlambda_types::block::SignedBlock>(test)
+        }
+        "BlockSignatures" => run_typed_test::<
+            ssz_types::BlockSignatures,
+            ethlambda_types::block::BlockSignatures,
+        >(test),
+        "AggregatedSignatureProof" => run_typed_test::<
+            ssz_types::AggregatedSignatureProof,
+            ethlambda_types::block::AggregatedSignatureProof,
+        >(test),
+        "SignedAggregatedAttestation" => run_typed_test::<
+            ssz_types::SignedAggregatedAttestation,
+            ethlambda_types::attestation::SignedAggregatedAttestation,
+        >(test),
+
+        // Unsupported types: skip with a message
+        other => {
+            println!("  Skipping unsupported type: {other}");
+            Ok(())
+        }
+    }
+}
+
+/// Run an SSZ test for a given fixture type `F` that converts into domain type `D`.
+///
+/// Tests:
+/// 1. JSON value deserializes into fixture type and converts to domain type
+/// 2. SSZ encoding matches expected serialized bytes
+/// 3. SSZ decoding from expected bytes re-encodes identically (round-trip)
+/// 4. Hash tree root matches expected root
+fn run_typed_test<F, D>(test: &SszTestCase) -> datatest_stable::Result<()>
+where
+    F: serde::de::DeserializeOwned + Into<D>,
+    D: libssz::SszEncode + libssz::SszDecode + HashTreeRoot,
+{
+    let expected_bytes = decode_hex(&test.serialized)
+        .map_err(|e| format!("Failed to decode serialized hex: {e}"))?;
+    let expected_root =
+        decode_hex_h256(&test.root).map_err(|e| format!("Failed to decode root hex: {e}"))?;
+
+    // Step 1: Deserialize JSON value into fixture type, then convert to domain type
+    let fixture_value: F = serde_json::from_value(test.value.clone())
+        .map_err(|e| format!("Failed to deserialize value: {e}"))?;
+    let domain_value: D = fixture_value.into();
+
+    // Step 2: SSZ encode and compare with expected serialized bytes
+    let encoded = <D as libssz::SszEncode>::to_ssz(&domain_value);
+    if encoded != expected_bytes {
+        return Err(format!(
+            "SSZ encoding mismatch for {}:\n  expected: 0x{}\n  got:      0x{}",
+            test.type_name,
+            hex::encode(&expected_bytes),
+            hex::encode(&encoded),
+        )
+        .into());
+    }
+
+    // Step 3: SSZ decode from expected bytes and re-encode (round-trip)
+    let decoded = D::from_ssz_bytes(&expected_bytes)
+        .map_err(|e| format!("SSZ decode failed for {}: {e:?}", test.type_name))?;
+    let re_encoded = <D as libssz::SszEncode>::to_ssz(&decoded);
+    if re_encoded != expected_bytes {
+        return Err(format!(
+            "SSZ round-trip mismatch for {}:\n  expected: 0x{}\n  got:      0x{}",
+            test.type_name,
+            hex::encode(&expected_bytes),
+            hex::encode(&re_encoded),
+        )
+        .into());
+    }
+
+    // Step 4: Verify hash tree root
+    let computed_root = HashTreeRoot::hash_tree_root(&domain_value);
+    if computed_root != expected_root {
+        return Err(format!(
+            "Hash tree root mismatch for {}:\n  expected: {expected_root}\n  got:      {computed_root}",
+            test.type_name,
+        )
+        .into());
+    }
+
+    Ok(())
+}
+
+datatest_stable::harness!({
+    test = run,
+    root = "../../../leanSpec/fixtures/consensus/ssz",
+    pattern = r".*\.json"
+});