participant module incl initializer and signer

curiecrypt · curiecrypt · commit 7ed4bacfae83 · 2025-05-15T16:45:45.000+03:00
participant updated for bls base changes

revise mod.rs

other clippy issues

more clippy issues
diff --git a/demo/protocol-demo/src/types.rs b/demo/protocol-demo/src/types.rs
@@ -1,7 +1,7 @@
-use mithril_stm::key_reg::KeyReg;
-use mithril_stm::stm::{
-    Stake, StmAggrSig, StmClerk, StmInitializer, StmParameters, StmSig, StmSigner,
-    StmVerificationKeyPoP,
+use mithril_stm::{
+    key_reg::KeyReg,
+    participant::{StmInitializer, StmSigner, StmVerificationKeyPoP},
+    stm::{Stake, StmAggrSig, StmClerk, StmParameters, StmSig},
 };
 
 use blake2::{digest::consts::U32, Blake2b};
diff --git a/mithril-common/src/crypto_helper/cardano/key_certification.rs b/mithril-common/src/crypto_helper/cardano/key_certification.rs
@@ -15,9 +15,12 @@ use crate::{
     StdError, StdResult,
 };
 
-use mithril_stm::key_reg::{ClosedKeyReg, KeyReg};
-use mithril_stm::stm::{Stake, StmInitializer, StmParameters, StmSigner, StmVerificationKeyPoP};
-use mithril_stm::RegisterError;
+use mithril_stm::{
+    key_reg::{ClosedKeyReg, KeyReg},
+    participant::{StmInitializer, StmSigner, StmVerificationKeyPoP},
+    stm::{Stake, StmParameters},
+    RegisterError,
+};
 
 use crate::crypto_helper::cardano::Sum6KesBytes;
 use anyhow::{anyhow, Context};
diff --git a/mithril-common/src/crypto_helper/types/alias.rs b/mithril-common/src/crypto_helper/types/alias.rs
@@ -5,7 +5,8 @@ use crate::crypto_helper::cardano::{
 
 use mithril_stm::{
     key_reg::ClosedKeyReg,
-    stm::{Index, Stake, StmClerk, StmParameters, StmSigner},
+    participant::StmSigner,
+    stm::{Index, Stake, StmClerk, StmParameters},
     AggregationError,
 };
 
@@ -32,10 +33,10 @@ pub type ProtocolParameters = StmParameters;
 /// Alias of [MithrilStm::Index](type@mithril_stm::stm::Index).
 pub type ProtocolLotteryIndex = Index;
 
-/// Alias of [MithrilStm:StmSigner](struct@mithril_stm::stm::StmSigner).
+/// Alias of [MithrilStm:StmSigner](struct@mithril_stm::participant::StmSigner).
 pub type ProtocolSigner = StmSigner<D>;
 
-/// Alias of a wrapper of [MithrilStm:StmInitializer](struct@mithril_stm::stm::StmInitializer).
+/// Alias of a wrapper of [MithrilStm:StmInitializer](struct@mithril_stm::participant::StmInitializer).
 pub type ProtocolInitializer = StmInitializerWrapper;
 
 /// Alias of [MithrilStm:StmClerk](struct@mithril_stm::stm::StmClerk).
diff --git a/mithril-common/src/crypto_helper/types/protocol_key.rs b/mithril-common/src/crypto_helper/types/protocol_key.rs
@@ -222,7 +222,7 @@ mod test {
         crypto_helper::ProtocolKey,
         test_utils::{fake_keys, TempDir},
     };
-    use mithril_stm::stm::StmVerificationKeyPoP;
+    use mithril_stm::participant::StmVerificationKeyPoP;
     use serde::{Deserialize, Serialize};
 
     static VERIFICATION_KEY: &str = fake_keys::signer_verification_key()[0];
diff --git a/mithril-common/src/crypto_helper/types/wrappers.rs b/mithril-common/src/crypto_helper/types/wrappers.rs
@@ -1,7 +1,8 @@
 use anyhow::Context;
 use hex::{FromHex, ToHex};
 use kes_summed_ed25519::kes::Sum6KesSig;
-use mithril_stm::stm::{StmAggrSig, StmAggrVerificationKey, StmSig, StmVerificationKeyPoP};
+use mithril_stm::participant::StmVerificationKeyPoP;
+use mithril_stm::stm::{StmAggrSig, StmAggrVerificationKey, StmSig};
 
 use crate::crypto_helper::{MKMapProof, MKProof, OpCert, ProtocolKey, ProtocolKeyCodec, D};
 use crate::entities::BlockRange;
diff --git a/mithril-common/src/test_utils/fake_keys.rs b/mithril-common/src/test_utils/fake_keys.rs
@@ -158,7 +158,7 @@ pub const fn signable_manifest_signature<'a>() -> [&'a str; 2] {
     ]
 }
 
-/// A list of pre json hex encoded [MithrilStm:StmVerificationKeyPoP](type@mithril_stm::stm::StmVerificationKeyPoP)
+/// A list of pre json hex encoded [MithrilStm:StmVerificationKeyPoP](type@mithril_stm::participant::StmVerificationKeyPoP)
 pub const fn signer_verification_key<'a>() -> [&'a str; 4] {
     [
         "7b22766b223a5b3134352c32332c3135382c31322c3138332c3230392c33322c3134302c33372c3132342c3136\
@@ -392,7 +392,8 @@ mod test {
     use super::*;
     use ed25519_dalek::VerifyingKey;
     use kes_summed_ed25519::kes::Sum6KesSig;
-    use mithril_stm::stm::{StmAggrSig, StmAggrVerificationKey, StmSig, StmVerificationKeyPoP};
+    use mithril_stm::stm::{StmAggrSig, StmAggrVerificationKey, StmSig};
+    use mithril_stm::participant::StmVerificationKeyPoP;
     use serde::{de::DeserializeOwned, Serialize};
     use std::any::type_name;
 
diff --git a/mithril-stm/README.md b/mithril-stm/README.md
@@ -63,7 +63,8 @@ The following is a simple example of the STM implementation:
 
 ```rust
 use mithril_stm::key_reg::KeyReg;
-use mithril_stm::stm::{StmClerk, StmInitializer, StmParameters, StmSig, StmSigner};
+use mithril_stm::stm::{StmClerk, StmParameters, StmSig};
+use mithril_stm::participant::{StmInitializer, StmSigner};
 use mithril_stm::AggregationError;
 
 use blake2::{digest::consts::U32, Blake2b};
diff --git a/mithril-stm/benches/size_benches.rs b/mithril-stm/benches/size_benches.rs
@@ -4,10 +4,8 @@ use blake2::{
     Blake2b, Digest,
 };
 use mithril_stm::key_reg::KeyReg;
-use mithril_stm::stm::{
-    CoreVerifier, Stake, StmClerk, StmInitializer, StmParameters, StmSig, StmSigRegParty,
-    StmSigner, StmVerificationKey,
-};
+use mithril_stm::participant::{StmInitializer, StmSigner, StmVerificationKey};
+use mithril_stm::stm::{CoreVerifier, Stake, StmClerk, StmParameters, StmSig, StmSigRegParty};
 use rand_chacha::ChaCha20Rng;
 use rand_core::{RngCore, SeedableRng};
 use rayon::iter::ParallelIterator;
diff --git a/mithril-stm/benches/stm.rs b/mithril-stm/benches/stm.rs
@@ -2,10 +2,8 @@ use blake2::digest::{Digest, FixedOutput};
 use blake2::{digest::consts::U32, Blake2b};
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
 use mithril_stm::key_reg::KeyReg;
-use mithril_stm::stm::{
-    CoreVerifier, Stake, StmAggrSig, StmClerk, StmInitializer, StmParameters, StmSigner,
-    StmVerificationKey,
-};
+use mithril_stm::participant::{StmInitializer, StmSigner, StmVerificationKey};
+use mithril_stm::stm::{CoreVerifier, Stake, StmAggrSig, StmClerk, StmParameters};
 use rand_chacha::ChaCha20Rng;
 use rand_core::{RngCore, SeedableRng};
 use rayon::prelude::*;
diff --git a/mithril-stm/examples/key_registration.rs b/mithril-stm/examples/key_registration.rs
@@ -3,7 +3,8 @@
 //! run presented in `tests/integration.rs`, we explicitly treat each party individually.
 use blake2::{digest::consts::U32, Blake2b};
 use mithril_stm::key_reg::{ClosedKeyReg, KeyReg};
-use mithril_stm::stm::{Stake, StmClerk, StmInitializer, StmParameters, StmVerificationKeyPoP};
+use mithril_stm::participant::{StmInitializer, StmVerificationKeyPoP};
+use mithril_stm::stm::{Stake, StmClerk, StmParameters};
 
 use rand_chacha::ChaCha20Rng;
 use rand_core::{RngCore, SeedableRng};
diff --git a/mithril-stm/src/lib.rs b/mithril-stm/src/lib.rs
@@ -20,3 +20,5 @@ pub mod bls_multi_signature;
 
 #[cfg(not(feature = "benchmark-internals"))]
 mod bls_multi_signature;
+
+pub mod participant;
diff --git a/mithril-stm/src/merkle_tree/leaf.rs b/mithril-stm/src/merkle_tree/leaf.rs
@@ -1,6 +1,7 @@
 use crate::bls_multi_signature::VerificationKey;
 use crate::error::MerkleTreeError;
-use crate::stm::{Stake, StmVerificationKey};
+use crate::participant::StmVerificationKey;
+use crate::stm::Stake;
 use blake2::Blake2b;
 use digest::consts::U32;
 use serde::{Deserialize, Serialize};
diff --git a/mithril-stm/src/participant/initializer.rs b/mithril-stm/src/participant/initializer.rs
@@ -0,0 +1,148 @@
+use crate::bls_multi_signature::{SigningKey, VerificationKeyPoP};
+use crate::key_reg::{ClosedKeyReg, RegParty};
+use crate::participant::StmSigner;
+use crate::stm::{Stake, StmParameters};
+use crate::RegisterError;
+use blake2::digest::Digest;
+use digest::FixedOutput;
+use rand_core::{CryptoRng, RngCore};
+use serde::{Deserialize, Serialize};
+
+/// Wrapper of the MultiSignature Verification key with proof of possession
+pub type StmVerificationKeyPoP = VerificationKeyPoP;
+
+/// Initializer for `StmSigner`.
+/// This is the data that is used during the key registration procedure.
+/// Once the latter is finished, this instance is consumed into an `StmSigner`.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct StmInitializer {
+    /// This participant's stake.
+    pub stake: Stake,
+    /// Current protocol instantiation parameters.
+    pub params: StmParameters,
+    /// Secret key.
+    pub(crate) sk: SigningKey,
+    /// Verification (public) key + proof of possession.
+    pub(crate) pk: StmVerificationKeyPoP,
+}
+
+impl StmInitializer {
+    /// Builds an `StmInitializer` that is ready to register with the key registration service.
+    /// This function generates the signing and verification key with a PoP, and initialises the structure.
+    pub fn setup<R: RngCore + CryptoRng>(params: StmParameters, stake: Stake, rng: &mut R) -> Self {
+        let sk = SigningKey::gen(rng);
+        let pk = StmVerificationKeyPoP::from(&sk);
+        Self {
+            stake,
+            params,
+            sk,
+            pk,
+        }
+    }
+
+    /// Extract the verification key.
+    pub fn verification_key(&self) -> StmVerificationKeyPoP {
+        self.pk
+    }
+
+    /// Build the `avk` for the given list of parties.
+    ///
+    /// Note that if this StmInitializer was modified *between* the last call to `register`,
+    /// then the resulting `StmSigner` may not be able to produce valid signatures.
+    ///
+    /// Returns an `StmSigner` specialized to
+    /// * this `StmSigner`'s ID and current stake
+    /// * this `StmSigner`'s parameter valuation
+    /// * the `avk` as built from the current registered parties (according to the registration service)
+    /// * the current total stake (according to the registration service)
+    /// # Error
+    /// This function fails if the initializer is not registered.
+    pub fn new_signer<D: Digest + Clone + FixedOutput>(
+        self,
+        closed_reg: ClosedKeyReg<D>,
+    ) -> Result<StmSigner<D>, RegisterError> {
+        let mut my_index = None;
+        for (i, rp) in closed_reg.reg_parties.iter().enumerate() {
+            if rp.0 == self.pk.vk {
+                my_index = Some(i as u64);
+                break;
+            }
+        }
+        if my_index.is_none() {
+            return Err(RegisterError::UnregisteredInitializer);
+        }
+
+        Ok(StmSigner::set_stm_signer(
+            my_index.unwrap(),
+            self.stake,
+            self.params,
+            self.sk,
+            self.pk.vk,
+            closed_reg,
+        ))
+    }
+
+    /// Creates a new core signer that does not include closed registration.
+    /// Takes `eligible_parties` as a parameter and determines the signer's index in the parties.
+    /// `eligible_parties` is verified and trusted which is only run by a full-node
+    /// that has already verified the parties.
+    pub fn new_core_signer<D: Digest + Clone + FixedOutput>(
+        self,
+        eligible_parties: &[RegParty],
+    ) -> Option<StmSigner<D>> {
+        let mut parties = eligible_parties.to_vec();
+        parties.sort_unstable();
+        let mut my_index = None;
+        for (i, rp) in parties.iter().enumerate() {
+            if rp.0 == self.pk.vk {
+                my_index = Some(i as u64);
+                break;
+            }
+        }
+        if let Some(index) = my_index {
+            Some(StmSigner::set_core_signer(
+                index,
+                self.stake,
+                self.params,
+                self.sk,
+                self.pk.vk,
+            ))
+        } else {
+            None
+        }
+    }
+
+    /// Convert to bytes
+    /// # Layout
+    /// * Stake (u64)
+    /// * Params
+    /// * Secret Key
+    /// * Public key (including PoP)
+    pub fn to_bytes(&self) -> [u8; 256] {
+        let mut out = [0u8; 256];
+        out[..8].copy_from_slice(&self.stake.to_be_bytes());
+        out[8..32].copy_from_slice(&self.params.to_bytes());
+        out[32..64].copy_from_slice(&self.sk.to_bytes());
+        out[64..].copy_from_slice(&self.pk.to_bytes());
+        out
+    }
+
+    /// Convert a slice of bytes to an `StmInitializer`
+    /// # Error
+    /// The function fails if the given string of bytes is not of required size.
+    pub fn from_bytes(bytes: &[u8]) -> Result<StmInitializer, RegisterError> {
+        let mut u64_bytes = [0u8; 8];
+        u64_bytes.copy_from_slice(&bytes[..8]);
+        let stake = u64::from_be_bytes(u64_bytes);
+        let params = StmParameters::from_bytes(&bytes[8..32])?;
+        let sk = SigningKey::from_bytes(&bytes[32..])?;
+        let pk = StmVerificationKeyPoP::from_bytes(&bytes[64..])?;
+
+        Ok(Self {
+            stake,
+            params,
+            sk,
+            pk,
+        })
+    }
+}
diff --git a/mithril-stm/src/participant/mod.rs b/mithril-stm/src/participant/mod.rs
@@ -0,0 +1,7 @@
+//! Mithril-stm participant including StmInitializer and StmSigner
+
+mod initializer;
+mod signer;
+
+pub use crate::participant::initializer::{StmInitializer, StmVerificationKeyPoP};
+pub use crate::participant::signer::{StmSigner, StmVerificationKey};
diff --git a/mithril-stm/src/participant/signer.rs b/mithril-stm/src/participant/signer.rs
diff --git a/mithril-stm/src/stm.rs b/mithril-stm/src/stm.rs
diff --git a/mithril-stm/tests/stm_core.rs b/mithril-stm/tests/stm_core.rs
diff --git a/mithril-stm/tests/stm_protocol.rs b/mithril-stm/tests/stm_protocol.rs

Original file line number	Diff line number	Diff line change
`@@ -158,7 +158,7 @@ pub const fn signable_manifest_signature<'a>() -> [&'a str; 2] {`
`158`	`158`	`]`
`159`	`159`	`}`
`160`	`160`
`161`		`-/// A list of pre json hex encoded [MithrilStm:StmVerificationKeyPoP](type@mithril_stm::stm::StmVerificationKeyPoP)`
	`161`	`+/// A list of pre json hex encoded [MithrilStm:StmVerificationKeyPoP](type@mithril_stm::participant::StmVerificationKeyPoP)`
`162`	`162`	`pub const fn signer_verification_key<'a>() -> [&'a str; 4] {`
`163`	`163`	`[`
`164`	`164`	`"7b22766b223a5b3134352c32332c3135382c31322c3138332c3230392c33322c3134302c33372c3132342c3136\`
`@@ -392,7 +392,8 @@ mod test {`
`392`	`392`	`use super::*;`
`393`	`393`	`use ed25519_dalek::VerifyingKey;`
`394`	`394`	`use kes_summed_ed25519::kes::Sum6KesSig;`
`395`		`- use mithril_stm::stm::{StmAggrSig, StmAggrVerificationKey, StmSig, StmVerificationKeyPoP};`
	`395`	`+ use mithril_stm::stm::{StmAggrSig, StmAggrVerificationKey, StmSig};`
	`396`	`+ use mithril_stm::participant::StmVerificationKeyPoP;`
`396`	`397`	`use serde::{de::DeserializeOwned, Serialize};`
`397`	`398`	`use std::any::type_name;`
`398`	`399`