Wired up Signer & SingleSigner in main #144, #145

Author: Alenar

mithril-signer/Cargo.lock

@@ -23,6 +23,8 @@ reqwest = { version = "0.11", features = ["json", "stream"] }
 tar = "0.4.38"
 flate2 = "1.0.23"
 thiserror = "1.0.31"
+async-trait = "0.1.52"
+tokio = { version = "1.17.0", features = ["full"] }
 
 hex = "0.4.3"
 rand_core   = "0.6.3"

mithril-signer/Cargo.toml

@@ -1,4 +1,6 @@
 {
     "network": "testnet",
-    "aggregator_endpoint": "http://localhost:8080/aggregator"
+    "aggregator_endpoint": "http://localhost:8080/aggregator",
+    "party_id": 0,
+    "run_interval": 20000
 }

mithril-signer/config/dev.json

@@ -1,4 +1,6 @@
 {
     "network": "testnet",
-    "aggregator_endpoint": "http://aggregator.api.mithril.network/aggregator"
+    "aggregator_endpoint": "http://aggregator.api.mithril.network/aggregator",
+    "party_id": 0,
+    "run_interval": 20000
 }

mithril-signer/config/testnet.json

@@ -1,10 +1,25 @@
+use async_trait::async_trait;
 use mithril_aggregator::entities::CertificatePending;
 #[cfg(test)]
 use mockall::automock;
 
 #[cfg_attr(test, automock)]
+#[async_trait]
 pub trait CertificateHandler {
-    fn retrieve_pending_certificate(&self) -> Result<Option<CertificatePending>, String>;
+    async fn retrieve_pending_certificate(&self) -> Result<Option<CertificatePending>, String>;
 
-    fn register_signatures(&self, signature: &str) -> Result<(), String>;
+    async fn register_signatures(&self, signature: &str) -> Result<(), String>;
+}
+
+pub struct CertificateHandlerNoOp {}
+
+#[async_trait]
+impl CertificateHandler for CertificateHandlerNoOp {
+    async fn retrieve_pending_certificate(&self) -> Result<Option<CertificatePending>, String> {
+        unimplemented!()
+    }
+
+    async fn register_signatures(&self, _signature: &str) -> Result<(), String> {
+        unimplemented!()
+    }
 }

mithril-signer/src/certificate_handler.rs

@@ -11,4 +11,12 @@ pub struct Config {
     /// Aggregator endpoint
     #[table(title = "Aggregator Endpoint")]
     pub aggregator_endpoint: String,
+
+    /// Party Id
+    #[table(title = "Party Id")]
+    pub party_id: u64,
+
+    /// Run Interval
+    #[table(title = "Interval between two signatures attempts")]
+    pub run_interval: u64,
 }

mithril-signer/src/entities.rs

@@ -1,9 +1,15 @@
+use crate::certificate_handler::CertificateHandlerNoOp;
 use crate::entities::Config;
+use crate::signer::Signer;
+use crate::single_signer::{key_decode_hex, MithrilSingleSigner};
 use clap::Parser;
+use mithril_aggregator::fake_data;
 use slog::{o, Drain, Level, Logger};
-use slog_scope::debug;
+use slog_scope::{debug, error, info};
 use std::env;
 use std::sync::Arc;
+use std::time::Duration;
+use tokio::time::sleep;
 
 mod certificate_handler;
 mod entities;
@@ -46,7 +52,8 @@ fn build_logger(min_level: Level) -> Logger {
     Logger::root(Arc::new(drain), o!())
 }
 
-fn main() {
+#[tokio::main]
+async fn main() {
     // Load args
     let args = Args::parse();
     let _guard = slog_scope::set_global_logger(build_logger(args.log_level()));
@@ -62,5 +69,19 @@ fn main() {
         .unwrap();
     debug!("Started"; "run_mode" => &run_mode, "config" => format!("{:?}", config));
 
-    println!("Hello, world!");
+    loop {
+        let fake_signer = fake_data::signer_keys(config.party_id).unwrap();
+        let single_signer = MithrilSingleSigner::new(
+            fake_signer.party_id,
+            key_decode_hex(&fake_signer.secret_key).unwrap(),
+        );
+        let certificate_handler = CertificateHandlerNoOp {};
+
+        let mut signer = Signer::new(Box::new(certificate_handler), Box::new(single_signer));
+        if let Err(e) = signer.run().await {
+            error!("{:?}", e)
+        }
+        info!("Sleeping for {}", config.run_interval);
+        sleep(Duration::from_millis(config.run_interval)).await;
+    }
 }

mithril-signer/src/main.rs

@@ -6,7 +6,7 @@ use mithril_aggregator::fake_data;
 use crate::certificate_handler::CertificateHandler;
 use crate::single_signer::SingleSigner;
 
-struct Signer {
+pub struct Signer {
     certificate_handler: Box<dyn CertificateHandler>,
     single_signer: Box<dyn SingleSigner>,
     current_beacon: Option<Beacon>,
@@ -21,9 +21,7 @@ pub enum SignerError {
 }
 
 impl Signer {
-    fn new(
-        _party_id: &str,
-        _signing_key: &str,
+    pub fn new(
         certificate_handler: Box<dyn CertificateHandler>,
         single_signer: Box<dyn SingleSigner>,
     ) -> Self {
@@ -34,10 +32,11 @@ impl Signer {
         }
     }
 
-    fn run(&mut self) -> Result<(), SignerError> {
+    pub async fn run(&mut self) -> Result<(), SignerError> {
         if let Some(pending_certificate) = self
             .certificate_handler
             .retrieve_pending_certificate()
+            .await
             .map_err(SignerError::RetrievePendingCertificateFailed)?
         {
             let must_register_signature = match &self.current_beacon {
@@ -49,7 +48,7 @@ impl Signer {
             };
 
             if must_register_signature {
-                let message = "message".as_bytes().to_vec();
+                let message = fake_data::digest();
                 let stake_distribution = fake_data::signers_with_stakes(5);
                 let signatures = self
                     .single_signer
@@ -60,7 +59,7 @@ impl Signer {
                     )
                     .map_err(|e| SignerError::SingleSignaturesComputeFailed(e.to_string()))?;
                 if !signatures.is_empty() {
-                    let _ = self.certificate_handler.register_signatures("");
+                    let _ = self.certificate_handler.register_signatures("").await;
                 }
             }
         }
@@ -76,8 +75,8 @@ mod tests {
     use crate::single_signer::{MockSingleSigner, SingleSignerError};
     use mithril_aggregator::fake_data;
 
-    #[test]
-    fn signer_doesnt_sign_when_there_is_no_pending_certificate() {
+    #[tokio::test]
+    async fn signer_doesnt_sign_when_there_is_no_pending_certificate() {
         let party_id = "";
         let signing_key = "";
         let mut mock_certificate_handler = MockCertificateHandler::new();
@@ -96,11 +95,11 @@ mod tests {
             Box::new(mock_certificate_handler),
             Box::new(mock_single_signer),
         );
-        assert!(signer.run().is_ok());
+        assert!(signer.run().await.is_ok());
     }
 
-    #[test]
-    fn signer_fails_when_pending_certificate_fails() {
+    #[tokio::test]
+    async fn signer_fails_when_pending_certificate_fails() {
         let party_id = "";
         let signing_key = "";
         let mut mock_certificate_handler = MockCertificateHandler::new();
@@ -117,12 +116,12 @@ mod tests {
         );
         assert_eq!(
             SignerError::RetrievePendingCertificateFailed("An Error".to_string()),
-            signer.run().unwrap_err()
+            signer.run().await.unwrap_err()
         );
     }
 
-    #[test]
-    fn signer_sign_when_triggered_by_pending_certificate() {
+    #[tokio::test]
+    async fn signer_sign_when_triggered_by_pending_certificate() {
         let party_id = "";
         let signing_key = "";
         let mut mock_certificate_handler = MockCertificateHandler::new();
@@ -150,12 +149,12 @@ mod tests {
             Box::new(mock_certificate_handler),
             Box::new(mock_single_signer),
         );
-        assert!(signer.run().is_ok());
-        assert!(signer.run().is_ok());
+        assert!(signer.run().await.is_ok());
+        assert!(signer.run().await.is_ok());
     }
 
-    #[test]
-    fn signer_sign_only_once_if_pending_certificate_has_not_changed() {
+    #[tokio::test]
+    async fn signer_sign_only_once_if_pending_certificate_has_not_changed() {
         let party_id = "";
         let signing_key = "";
         let mut mock_certificate_handler = MockCertificateHandler::new();
@@ -179,12 +178,12 @@ mod tests {
             Box::new(mock_certificate_handler),
             Box::new(mock_single_signer),
         );
-        assert!(signer.run().is_ok());
-        assert!(signer.run().is_ok());
+        assert!(signer.run().await.is_ok());
+        assert!(signer.run().await.is_ok());
     }
 
-    #[test]
-    fn signer_does_not_send_signatures_if_none_are_computed() {
+    #[tokio::test]
+    async fn signer_does_not_send_signatures_if_none_are_computed() {
         let party_id = "";
         let signing_key = "";
         let mut mock_certificate_handler = MockCertificateHandler::new();
@@ -207,11 +206,11 @@ mod tests {
             Box::new(mock_certificate_handler),
             Box::new(mock_single_signer),
         );
-        assert!(signer.run().is_ok());
+        assert!(signer.run().await.is_ok());
     }
 
-    #[test]
-    fn signer_fails_if_signature_computation_fails() {
+    #[tokio::test]
+    async fn signer_fails_if_signature_computation_fails() {
         let party_id = "";
         let signing_key = "";
         let mut mock_certificate_handler = MockCertificateHandler::new();
@@ -235,7 +234,7 @@ mod tests {
             SignerError::SingleSignaturesComputeFailed(
                 SingleSignerError::UnregisteredVerificationKey().to_string()
             ),
-            signer.run().unwrap_err()
+            signer.run().await.unwrap_err()
         );
     }
 }