mithril_common/crypto_helper/cardano/kes/
signer_fake.rs

1use std::collections::VecDeque;
2
3use kes_summed_ed25519::kes::Sum6KesSig;
4use std::sync::Mutex;
5
6use crate::{
7    StdResult,
8    crypto_helper::{
9        KesPeriod, KesSigner, OpCert,
10        cardano::kes::{
11            KesSignerStandard,
12            tests_setup::{
13                KesCryptographicMaterialForTest, KesPartyIndexForTest,
14                create_kes_cryptographic_material,
15            },
16        },
17    },
18};
19
20type KesSignatureResult = StdResult<(Sum6KesSig, OpCert)>;
21
22/// Fake KES Signer implementation.
23pub struct KesSignerFake {
24    results: Mutex<VecDeque<KesSignatureResult>>,
25}
26
27impl KesSignerFake {
28    /// Creates a new `KesSignerFake` instance.
29    pub fn new(results: Vec<KesSignatureResult>) -> Self {
30        Self {
31            results: Mutex::new(results.into()),
32        }
33    }
34
35    /// Returns a dummy signature result that is always successful.
36    pub fn dummy_signature() -> (Sum6KesSig, OpCert) {
37        let KesCryptographicMaterialForTest {
38            party_id: _,
39            operational_certificate_file,
40            kes_secret_key_file,
41        } = create_kes_cryptographic_material(
42            1 as KesPartyIndexForTest,
43            0 as KesPeriod,
44            "fake_kes_signer_returns_signature_batches_in_expected_order",
45        );
46        let message = b"Test message for KES signing";
47        let kes_signer = KesSignerStandard::new(kes_secret_key_file, operational_certificate_file);
48        let kes_signing_period = 1;
49        let (kes_signature, op_cert) = kes_signer
50            .sign(message, kes_signing_period)
51            .expect("Signing should not fail");
52
53        (kes_signature, op_cert)
54    }
55
56    /// Returns a dummy signature result that always fails.
57    pub fn dummy_signature_result_err() -> KesSignatureResult {
58        Err(anyhow::anyhow!("Dummy error"))
59    }
60}
61
62impl KesSigner for KesSignerFake {
63    fn sign(&self, _message: &[u8], _kes_period: KesPeriod) -> KesSignatureResult {
64        let mut results = self.results.lock().unwrap();
65
66        results.pop_front().unwrap()
67    }
68}
69
70#[cfg(test)]
71mod tests {
72    use super::*;
73
74    #[test]
75    fn fake_kes_signer_returns_signature_batches_in_expected_order() {
76        let KesCryptographicMaterialForTest {
77            party_id: _,
78            operational_certificate_file,
79            kes_secret_key_file,
80        } = create_kes_cryptographic_material(
81            1 as KesPartyIndexForTest,
82            0 as KesPeriod,
83            "fake_kes_signer_returns_signature_batches_in_expected_order",
84        );
85        let message = b"Test message for KES signing";
86        let kes_signer = KesSignerStandard::new(kes_secret_key_file, operational_certificate_file);
87        let kes_signing_period = 1;
88        let (kes_signature, op_cert) = kes_signer
89            .sign(message, kes_signing_period)
90            .expect("Signing should not fail");
91        let fake_kes_signer = KesSignerFake::new(vec![
92            Ok((kes_signature, op_cert.clone())),
93            Err(anyhow::anyhow!("Fake error")),
94        ]);
95
96        let (kes_signature_1, op_cert_1) = fake_kes_signer
97            .sign(message, kes_signing_period)
98            .expect("Signing should not fail");
99        assert_eq!(kes_signature, kes_signature_1);
100        assert_eq!(op_cert, op_cert_1);
101
102        fake_kes_signer
103            .sign(message, kes_signing_period)
104            .expect_err("Signing should fail");
105    }
106}