only add stable version to CI

Author: Prabhat1308

Diff for: .github/workflows/prod.yml

@@ -16,7 +16,7 @@ jobs:
         runs-on: ubuntu-latest
         strategy:
             matrix:
-                rust: [stable, beta, nightly]
+                rust: [stable]
 
         steps:
           - uses: actions/checkout@v2

Diff for: rustfmt.toml

@@ -1,2 +1,2 @@
 use_small_heuristics = "Max"
-imports_granularity = "Crate"
+

Diff for: src/cli.rs

@@ -146,47 +146,28 @@ impl Cli {
     pub async fn run(self) -> anyhow::Result<()> {
         init_log(self.verbose)?;
         match self.commands {
-            Commands::GenerateKeypair {
-                folder,
-                id,
-                scheme,
-                address,
-                tls_disable,
-            } => {
+            Commands::GenerateKeypair { folder, id, scheme, address, tls_disable } => {
                 //  - Default boolean value is true, omitting '--tls_disable' leads to tls_disable:true
                 //  - We want to keep CLI in sync with golang implementation
                 //  - From here tls:true means tls enabled, this can probably be done more elegantly
                 let tls = !tls_disable;
                 crate::core::schemes::gen_keypair(scheme, &folder, tls, id, address)?
             }
-            Commands::Start {
-                folder,
-                id,
-                private_listen,
-                control,
-            } => control::start(&folder, id, &control, private_listen).await?,
+            Commands::Start { folder, id, private_listen, control } => {
+                control::start(&folder, id, &control, private_listen).await?
+            }
 
             Commands::Stop { control, id } => control::stop(&control, id.as_ref()).await?,
 
             Commands::Show(show) => match show {
                 Show::Public { control, id } => control::public_key_request(&control, id).await?,
             },
             Commands::Util(util) => match util {
-                Util::Check {
-                    tls_disable,
-                    id,
-                    addresses,
-                } => todo!(),
+                Util::Check { tls_disable, id, addresses } => todo!(),
                 Util::ListSchemes { control } => control::list_schemes(&control).await?,
                 Util::PoolInfo { control } => control::pool_info(&control).await?,
             },
-            Commands::Share {
-                control,
-                leader,
-                id,
-                tls_disable,
-                connect,
-            } => {
+            Commands::Share { control, leader, id, tls_disable, connect } => {
                 //  - Default boolean value is true, omitting '--tls_disable' leads to tls_disable:true
                 //  - We want to keep CLI in sync with golang implementation
                 //  - From here tls:true means tls enabled, this can probably be done more elegantly

Diff for: src/core/beacon.rs

@@ -125,13 +125,7 @@ impl<S: Scheme> Beacon<S> {
     ) -> Self {
         let span = info_span!("", id = format!("{private_listen}.{id}"));
 
-        Self(Arc::new(InnerNode {
-            beacon_id: id.clone(),
-            fs,
-            keypair,
-            pool,
-            span,
-        }))
+        Self(Arc::new(InnerNode { beacon_id: id.clone(), fs, keypair, pool, span }))
     }
 
     pub fn start(self, mut rx: Receiver<BeaconCmd>) {
@@ -299,18 +293,11 @@ impl<S: Scheme> Beacon<S> {
         secret: &[u8],
     ) -> Result<DkgConfig<S>> {
         if secret != p.secret_proof {
-            bail!(
-                "secret_proof is not valid, beacon_id: {}",
-                self.beacon_id.as_str()
-            );
+            bail!("secret_proof is not valid, beacon_id: {}", self.beacon_id.as_str());
         }
 
         if p.new_group.scheme_id != S::ID {
-            bail!(
-                "invalid scheme, expected: {}, received: {}",
-                S::ID,
-                p.new_group.scheme_id,
-            );
+            bail!("invalid scheme, expected: {}, received: {}", S::ID, p.new_group.scheme_id,);
         }
         let leader_key = Affine::deserialize(leader_key)?;
 
@@ -321,10 +308,7 @@ impl<S: Scheme> Beacon<S> {
         }
         let group: Group<S> = p.new_group.try_into()?;
         let Some(dkg_index) = group.find_index(self.keypair.public()) else {
-            bail!(
-                "local node {} is not found in group_file",
-                self.keypair.public().address()
-            )
+            bail!("local node {} is not found in group_file", self.keypair.public().address())
         };
 
         Ok(DkgConfig::new(leader_key, group, p.dkg_timeout, dkg_index))
@@ -333,9 +317,7 @@ impl<S: Scheme> Beacon<S> {
 
 impl From<String> for BeaconID {
     fn from(value: String) -> Self {
-        Self {
-            inner: value.into(),
-        }
+        Self { inner: value.into() }
     }
 }
 

Diff for: src/core/chain.rs

@@ -118,11 +118,7 @@ impl<S: Scheme> ChainHandler<S> {
 
     async fn add_partial(&mut self, p: PartialBeaconPacket) -> Result<()> {
         let sig_sh = SigShare::deserialize(&p.partial_sig)?;
-        if self
-            .sigs_buf
-            .iter()
-            .any(|stored| stored.index() == sig_sh.index())
-        {
+        if self.sigs_buf.iter().any(|stored| stored.index() == sig_sh.index()) {
             debug!(parent: self.node.span(), "ignoring dublicated partial, index: {}, round: {}", sig_sh.index(), p.round);
             return Ok(());
         }
@@ -135,11 +131,7 @@ impl<S: Scheme> ChainHandler<S> {
         let msg = S::Beacon::digest(&p.previous_signature, p.round);
         let key = &self.share.public().eval(sig_sh.index()).v;
         if S::bls_verify(key, sig_sh.value(), &msg).is_err() {
-            bail!(
-                "invalid bls signarure, index: {}, round: {}",
-                sig_sh.index(),
-                p.round
-            );
+            bail!("invalid bls signarure, index: {}, round: {}", sig_sh.index(), p.round);
         }
 
         debug!(parent: self.node.span(), "Added valid partial, index: {}, round: {}, last_stored.round: {}", sig_sh.index(), p.round, self.last_stored.round);
@@ -183,11 +175,7 @@ impl<S: Scheme> ChainHandler<S> {
                 metadata: From::from(&self.node.beacon_id),
             };
 
-            if !self
-                .sigs_buf
-                .iter()
-                .any(|stored| stored.index() == our_partial.index())
-            {
+            if !self.sigs_buf.iter().any(|stored| stored.index() == our_partial.index()) {
                 self.try_recover(our_partial, &msg);
             }
             let _ = self.node.pool.send(PoolCmd::Partial(packet)).await;

Diff for: src/core/daemon.rs

@@ -54,13 +54,7 @@ impl Daemon {
         let pool = Pool::start(false, logger.register_pool());
         let beacons = MultiBeacon::new(beacon_id, base_folder, &private_listen, pool.clone())?;
         let (stop_daemon, _) = tokio::sync::broadcast::channel::<()>(1);
-        let daemon = Self {
-            beacons,
-            stop_daemon,
-            logger,
-            private_listen,
-            pool,
-        };
+        let daemon = Self { beacons, stop_daemon, logger, private_listen, pool };
 
         Ok(Arc::new(daemon))
     }
@@ -127,9 +121,7 @@ impl Daemon {
             .await
             .map_err(|e| Status::invalid_argument(e.to_string()))?;
 
-        callback
-            .await
-            .map_or_else(|_| Err(Status::internal(INTERNAL_ERR)), Ok)
+        callback.await.map_or_else(|_| Err(Status::internal(INTERNAL_ERR)), Ok)
     }
 
     pub async fn broadcast_dkg_bundle(&self, bundle: Bundle, id: &str) -> Result<(), Status> {
@@ -166,14 +158,9 @@ impl Daemon {
 
     pub async fn pool_status(&self) -> Result<String, Status> {
         let (sender, callback) = oneshot::channel();
-        self.pool
-            .send(PoolCmd::Status(sender))
-            .await
-            .map_err(|e| Status::from_error(e.into()))?;
+        self.pool.send(PoolCmd::Status(sender)).await.map_err(|e| Status::from_error(e.into()))?;
 
-        callback
-            .await
-            .map_or_else(|_| Err(Status::internal(INTERNAL_ERR)), Ok)
+        callback.await.map_or_else(|_| Err(Status::internal(INTERNAL_ERR)), Ok)
     }
 }