Enhance STM library readability - Golden tests

mithril-stm/CHANGELOG.md

@@ -5,6 +5,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 0.5.4 (10-07-2025)
+
+### Added
+
+- Added golden tests for JSON (de)serialization.
+
 ## 0.5.3 (10-07-2025)
 
 ### Added

mithril-stm/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mithril-stm"
-version = "0.5.3"
+version = "0.5.4"
 edition = { workspace = true }
 authors = { workspace = true }
 homepage = { workspace = true }
@@ -50,6 +50,7 @@ num-rational = "0.4.2"
 proptest = "1.7.0"
 rand = "0.9.2"
 rand_chacha = { workspace = true }
+serde_json = { workspace = true }
 
 [[bench]]
 name = "multi_sig"

mithril-stm/src/aggregate_signature/signature.rs

@@ -200,7 +200,7 @@ impl<D: Clone + Digest + FixedOutput + Send + Sync> AggregateSignature<D> {
 mod tests {
     use super::*;
 
-    mod aggregate_signature_type {
+    mod aggregate_signature_type_golden {
         use super::*;
 
         #[test]
@@ -215,4 +215,117 @@ mod tests {
             );
         }
     }
+
+    mod aggregate_signature_golden_concatenation {
+        use blake2::{Blake2b, digest::consts::U32};
+        use rand_chacha::ChaCha20Rng;
+        use rand_core::SeedableRng;
+
+        use crate::bls_multi_signature::{BlsSigningKey, BlsVerificationKeyProofOfPossession};
+        use crate::{
+            AggregateSignature, AggregateSignatureType, Clerk, ClosedKeyRegistration,
+            KeyRegistration, Parameters, Signer,
+        };
+
+        type D = Blake2b<U32>;
+
+        const GOLDEN_JSON: &str = r#"
+        {
+            "signatures": [
+                [
+                {
+                    "sigma": [
+                    149, 157, 201, 187, 140, 54, 0, 128, 209, 88, 16, 203, 61, 78, 77, 98,
+                    161, 133, 58, 152, 29, 74, 217, 113, 64, 100, 10, 161, 186, 167, 133,
+                    114, 211, 153, 218, 56, 223, 84, 105, 242, 41, 54, 224, 170, 208, 185,
+                    126, 83
+                    ],
+                    "indexes": [1, 4, 5, 8],
+                    "signer_index": 0
+                },
+                [
+                    [
+                    143, 161, 255, 48, 78, 57, 204, 220, 25, 221, 164, 252, 248, 14, 56,
+                    126, 186, 135, 228, 188, 145, 181, 52, 200, 97, 99, 213, 46, 0, 199,
+                    193, 89, 187, 88, 29, 135, 173, 244, 86, 36, 83, 54, 67, 164, 6, 137,
+                    94, 72, 6, 105, 128, 128, 93, 48, 176, 11, 4, 246, 138, 48, 180, 133,
+                    90, 142, 192, 24, 193, 111, 142, 31, 76, 111, 110, 234, 153, 90, 208,
+                    192, 31, 124, 95, 102, 49, 158, 99, 52, 220, 165, 94, 251, 68, 69,
+                    121, 16, 224, 194
+                    ],
+                    1
+                ]
+                ],
+                [
+                {
+                    "sigma": [
+                    149, 169, 22, 201, 216, 97, 163, 188, 115, 210, 217, 236, 233, 161,
+                    201, 13, 42, 132, 12, 63, 5, 31, 120, 22, 78, 177, 125, 134, 208, 205,
+                    73, 58, 247, 141, 59, 62, 187, 81, 213, 30, 153, 218, 41, 42, 110,
+                    156, 161, 205
+                    ],
+                    "indexes": [0, 3, 6],
+                    "signer_index": 1
+                },
+                [
+                    [
+                    145, 56, 175, 32, 122, 187, 214, 226, 251, 148, 88, 9, 1, 103, 159,
+                    146, 80, 166, 107, 243, 251, 236, 41, 28, 111, 128, 207, 164, 132,
+                    147, 228, 83, 246, 228, 170, 68, 89, 78, 60, 28, 123, 130, 88, 234,
+                    38, 97, 42, 65, 1, 100, 53, 18, 78, 131, 8, 61, 122, 131, 238, 84,
+                    233, 223, 154, 118, 118, 73, 28, 27, 101, 78, 80, 233, 123, 206, 220,
+                    174, 134, 205, 71, 110, 112, 180, 97, 98, 0, 113, 69, 145, 231, 168,
+                    43, 173, 172, 56, 104, 208
+                    ],
+                    1
+                ]
+                ]
+            ],
+            "batch_proof": { "values": [], "indices": [0, 1], "hasher": null }
+        }
+        "#;
+
+        fn golden_value() -> AggregateSignature<D> {
+            let mut rng = ChaCha20Rng::from_seed([0u8; 32]);
+            let msg = [0u8; 16];
+            let params = Parameters {
+                m: 10,
+                k: 5,
+                phi_f: 0.8,
+            };
+            let sk_1 = BlsSigningKey::generate(&mut rng);
+            let sk_2 = BlsSigningKey::generate(&mut rng);
+            let pk_1 = BlsVerificationKeyProofOfPossession::from(&sk_1);
+            let pk_2 = BlsVerificationKeyProofOfPossession::from(&sk_2);
+            let mut key_reg = KeyRegistration::init();
+            key_reg.register(1, pk_1).unwrap();
+            key_reg.register(1, pk_2).unwrap();
+            let closed_key_reg: ClosedKeyRegistration<D> = key_reg.close();
+            let clerk = Clerk::new_clerk_from_closed_key_registration(&params, &closed_key_reg);
+            let signer_1 = Signer::set_signer(0, 1, params, sk_1, pk_1.vk, closed_key_reg.clone());
+            let signer_2 = Signer::set_signer(1, 1, params, sk_2, pk_2.vk, closed_key_reg);
+            let signature_1 = signer_1.sign(&msg).unwrap();
+            let signature_2 = signer_2.sign(&msg).unwrap();
+
+            clerk
+                .aggregate_signatures_with_type(
+                    &[signature_1, signature_2],
+                    &msg,
+                    AggregateSignatureType::Concatenation,
+                )
+                .unwrap()
+        }
+
+        #[test]
+        fn golden_conversions() {
+            let value: AggregateSignature<D> = serde_json::from_str(GOLDEN_JSON)
+                .expect("This JSON deserialization should not fail");
+
+            let serialized =
+                serde_json::to_string(&value).expect("This JSON serialization should not fail");
+            let golden_serialized = serde_json::to_string(&golden_value())
+                .expect("This JSON serialization should not fail");
+            assert_eq!(golden_serialized, serialized);
+        }
+    }
 }

mithril-stm/src/bls_multi_signature/proof_of_possession.rs

@@ -68,3 +68,35 @@ impl From<&BlsSigningKey> for BlsProofOfPossession {
         Self { k1, k2 }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    mod golden {
+
+        use rand_chacha::ChaCha20Rng;
+        use rand_core::SeedableRng;
+
+        use crate::bls_multi_signature::{BlsProofOfPossession, BlsSigningKey};
+
+        const GOLDEN_JSON: &str = r#"[168,50,233,193,15,136,65,72,123,148,129,176,38,198,209,47,28,204,176,144,57,251,42,28,66,76,89,97,158,63,54,198,194,176,135,221,14,185,197,225,202,98,243,74,233,225,143,151,147,177,170,117,66,165,66,62,33,216,232,75,68,114,195,22,100,65,44,198,4,166,102,233,253,240,59,175,60,117,142,114,140,122,17,87,110,187,1,17,10,195,154,13,249,86,54,226]"#;
+
+        fn golden_value() -> BlsProofOfPossession {
+            let mut rng = ChaCha20Rng::from_seed([0u8; 32]);
+            let sk = BlsSigningKey::generate(&mut rng);
+            BlsProofOfPossession::from(&sk)
+        }
+
+        #[test]
+        fn golden_conversions() {
+            let value = serde_json::from_str(GOLDEN_JSON)
+                .expect("This JSON deserialization should not fail");
+            assert_eq!(golden_value(), value);
+
+            let serialized =
+                serde_json::to_string(&value).expect("This JSON serialization should not fail");
+            let golden_serialized = serde_json::to_string(&golden_value())
+                .expect("This JSON serialization should not fail");
+            assert_eq!(golden_serialized, serialized);
+        }
+    }
+}

mithril-stm/src/bls_multi_signature/signature.rs

@@ -208,3 +208,36 @@ impl Ord for BlsSignature {
         self.compare_signatures(other)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    mod golden {
+
+        use rand_chacha::ChaCha20Rng;
+        use rand_core::SeedableRng;
+
+        use crate::bls_multi_signature::{BlsSignature, BlsSigningKey};
+
+        const GOLDEN_JSON: &str = r#"[132,95,124,197,185,105,193,171,114,182,52,171,205,119,202,188,2,213,61,125,219,242,10,131,53,219,53,197,157,42,152,194,234,161,244,204,2,134,47,179,176,49,200,232,120,241,180,246]"#;
+
+        fn golden_value() -> BlsSignature {
+            let mut rng = ChaCha20Rng::from_seed([0u8; 32]);
+            let sk = BlsSigningKey::generate(&mut rng);
+            let msg = [0u8; 32];
+            sk.sign(&msg)
+        }
+
+        #[test]
+        fn golden_conversions() {
+            let value = serde_json::from_str(GOLDEN_JSON)
+                .expect("This JSON deserialization should not fail");
+            assert_eq!(golden_value(), value);
+
+            let serialized =
+                serde_json::to_string(&value).expect("This JSON serialization should not fail");
+            let golden_serialized = serde_json::to_string(&golden_value())
+                .expect("This JSON serialization should not fail");
+            assert_eq!(golden_serialized, serialized);
+        }
+    }
+}

mithril-stm/src/bls_multi_signature/signing_key.rs

@@ -47,3 +47,36 @@ impl BlsSigningKey {
         self.0.clone()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    mod golden {
+
+        use rand_chacha::ChaCha20Rng;
+        use rand_core::SeedableRng;
+
+        use super::*;
+
+        const GOLDEN_JSON: &str = r#"[64, 129, 87, 121, 27, 239, 221, 215, 2, 103, 45, 207, 207, 201, 157, 163, 81, 47, 156, 14, 168, 24, 137, 15, 203, 106, 183, 73, 88, 14, 242, 207]"#;
+
+        fn golden_value() -> BlsSigningKey {
+            let mut rng = ChaCha20Rng::from_seed([0u8; 32]);
+            BlsSigningKey::generate(&mut rng)
+        }
+
+        #[test]
+        fn golden_conversions() {
+            let value = serde_json::from_str(GOLDEN_JSON)
+                .expect("This JSON deserialization should not fail");
+            assert_eq!(golden_value(), value);
+
+            let serialized =
+                serde_json::to_string(&value).expect("This JSON serialization should not fail");
+            let golden_serialized = serde_json::to_string(&golden_value())
+                .expect("This JSON serialization should not fail");
+            assert_eq!(golden_serialized, serialized);
+        }
+    }
+}

mithril-stm/src/bls_multi_signature/verification_key.rs

@@ -209,3 +209,45 @@ impl From<&BlsSigningKey> for BlsVerificationKeyProofOfPossession {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    mod golden {
+
+        use rand_chacha::ChaCha20Rng;
+        use rand_core::SeedableRng;
+
+        use super::*;
+
+        const GOLDEN_JSON: &str = r#"
+            {
+                "vk": [143, 161, 255, 48, 78, 57, 204, 220, 25, 221, 164, 252, 248, 14, 56, 126, 186, 135, 228, 188, 145, 181, 52, 200, 97, 99, 213, 46, 0, 199, 193, 89, 187, 88, 29, 135, 173, 244, 86, 36, 83, 54, 67, 164, 6, 137, 94, 72, 6, 105, 128, 128, 93, 48, 176, 11, 4, 246, 138, 48, 180, 133, 90, 142, 192, 24, 193, 111, 142, 31, 76, 111, 110, 234, 153, 90, 208, 192, 31, 124, 95, 102, 49, 158, 99, 52, 220, 165, 94, 251, 68, 69, 121, 16, 224, 194],
+                "pop": [168, 50, 233, 193, 15, 136, 65, 72, 123, 148, 129, 176, 38, 198, 209, 47, 28, 204, 176, 144, 57, 251, 42, 28, 66, 76, 89, 97, 158, 63, 54, 198, 194, 176, 135, 221, 14, 185, 197, 225, 202, 98, 243, 74, 233, 225, 143, 151, 147, 177, 170, 117, 66, 165, 66, 62, 33, 216, 232, 75, 68, 114, 195, 22, 100, 65, 44, 198, 4, 166, 102, 233, 253, 240, 59, 175, 60, 117, 142, 114, 140, 122, 17, 87, 110, 187, 1, 17, 10, 195, 154, 13, 249, 86, 54, 226]
+            }
+        "#;
+
+        fn golden_value() -> BlsVerificationKeyProofOfPossession {
+            let mut rng = ChaCha20Rng::from_seed([0u8; 32]);
+            let sk = BlsSigningKey::generate(&mut rng);
+            BlsVerificationKeyProofOfPossession {
+                vk: BlsVerificationKey::from(&sk),
+                pop: BlsProofOfPossession::from(&sk),
+            }
+        }
+
+        #[test]
+        fn golden_conversions() {
+            let value = serde_json::from_str(GOLDEN_JSON)
+                .expect("This JSON deserialization should not fail");
+            assert_eq!(golden_value(), value);
+
+            let serialized =
+                serde_json::to_string(&value).expect("This JSON serialization should not fail");
+            let golden_serialized = serde_json::to_string(&golden_value())
+                .expect("This JSON serialization should not fail");
+            assert_eq!(golden_serialized, serialized);
+        }
+    }
+}

mithril-stm/src/parameters.rs

@@ -48,3 +48,41 @@ impl Parameters {
         Ok(Self { m, k, phi_f })
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    mod golden {
+        use super::*;
+
+        const GOLDEN_JSON: &str = r#"
+            {
+                "m": 20973,
+                "k": 2422,
+                "phi_f": 0.2
+            }
+        "#;
+
+        fn golden_value() -> Parameters {
+            Parameters {
+                m: 20973,
+                k: 2422,
+                phi_f: 0.2,
+            }
+        }
+
+        #[test]
+        fn golden_conversions() {
+            let value = serde_json::from_str(GOLDEN_JSON)
+                .expect("This JSON deserialization should not fail");
+            assert_eq!(golden_value(), value);
+
+            let serialized =
+                serde_json::to_string(&value).expect("This JSON serialization should not fail");
+            let golden_serialized = serde_json::to_string(&golden_value())
+                .expect("This JSON serialization should not fail");
+            assert_eq!(golden_serialized, serialized);
+        }
+    }
+}