chore: minor-fixes (#17)

* correct typos/grammar
* fix: remove anyhow::Result from key module
* remove unused rpc

Author: version513

src/chain/cache.rs

@@ -9,14 +9,14 @@ use crate::{
 use energon::kyber::tbls::SigShare;
 use std::collections::VecDeque;
 
-/// Partials that are up to this amount of rounds more than the last
-/// beacon we have - it is useful for quick catchup.
+/// Partials that are up to this number of rounds
+/// beyond the last beacon we have - useful for quick catchup.
 pub const CACHE_LIMIT_ROUNDS: u64 = 3;
 
 /// Logical errors for partial cache.
 #[derive(thiserror::Error, Debug)]
 pub enum CacheError {
-    #[error("new stored round {latest_stored} is less then height {height}")]
+    #[error("new stored round {latest_stored} is less than height {height}")]
     Height { latest_stored: u64, height: u64 },
     #[error("invalid structure: allowed rounds {allowed:?}, height {height}")]
     Structure { allowed: Vec<u64>, height: u64 },
@@ -32,8 +32,8 @@ struct PartialsUnchecked {
 }
 
 /// Partial cache holds 2 types of shares:
-///  - [`PartialBeaconPacket`] unchecked BLS signature .
-///  - [`SigShare`] checked BLS signature .
+///  - [`PartialBeaconPacket`] unchecked BLS signature.
+///  - [`SigShare`] checked BLS signature.
 ///
 /// Partial cache structure:
 ///                  n           n + 1       n + 2 .. n + 2 + `CACHE_LIMIT_ROUNDS`
@@ -63,11 +63,12 @@ impl<S: Scheme> PartialCache<S> {
         }
     }
 
-    /// Adds packet into the corresponding round cache if the round of packet is allowed
-    /// and signature of packet is not duplicated.
+    /// Adds a packet to the corresponding round cache if the packet's
+    /// round is allowed and the packet's signature is not duplicated.
     ///
-    /// Cache _might_ contain more than one packet with same share index for given round.
-    /// This is possible if leaved node is not in proper state: old index collided with new index of some valid node.
+    /// Corner case: cache _may_ contain more than one packet with the same
+    /// share index for a given round. This is possible if leaved node is not
+    /// in proper state and old index collided with new index of some valid node.
     /// Such invalid packets will be discarded at BLS signature check.
     pub fn add_packet(&mut self, packet: PartialBeaconPacket) -> Option<bool> {
         if let Some(r_cache) = self
@@ -100,7 +101,8 @@ impl<S: Scheme> PartialCache<S> {
         self.valid_sigs.iter().any(|s| s.index() == index)
     }
 
-    /// Adds sigshare to partial cache. Returns slice of sigshares *sorted by index* if their number hits the threshold.
+    /// Adds sigshare to partial cache. Returns slice of sigshares *sorted by index*
+    /// if their count reaches the threshold.
     ///
     /// WARNING: bls signature validity and round value must be prechecked on caller side.
     pub fn add_prechecked(
@@ -125,7 +127,7 @@ impl<S: Scheme> PartialCache<S> {
         Some(self.valid_sigs.as_slice())
     }
 
-    /// Updates cache state if argument is bigger than cache metadata.
+    /// Updates cache state if argument is greater than cache height.
     /// Returns packets to verify for `latest_stored +1` round if such packets exist.
     fn update(&mut self, latest_stored: u64) -> Result<Option<PartialsUnchecked>, CacheError> {
         #[allow(clippy::comparison_chain, reason = "exhaustive")]
@@ -146,12 +148,12 @@ impl<S: Scheme> PartialCache<S> {
             for _ in 0..delta {
                 match self.rounds_cache.pop_front() {
                     Some(packets) => {
-                        // Add corresponding entry for new allowed round
+                        // Add corresponding entry for new allowed round.
                         self.rounds_cache.push_back(PartialsUnchecked {
                             round: packets.round + CACHE_LIMIT_ROUNDS,
                             packets: Vec::with_capacity(self.thr),
                         });
-                        // Stop at wanted round to aggregate
+                        // Stop at wanted round to aggregate.
                         if packets.round == self.height + 1 {
                             if packets.packets.is_empty() {
                                 return Ok(None);

src/chain/epoch.rs

@@ -17,7 +17,8 @@ use energon::{
 pub struct EpochNode<S: Scheme> {
     /// Node address.
     peer: Address,
-    /// Node public share is computed by evaluating public sharing polynomial at the node index.
+    /// Node public share is computed by evaluating public
+    /// sharing polynomial at the node index.
     share: PubShare<S>,
 }
 
@@ -27,7 +28,8 @@ impl<S: Scheme> EpochNode<S> {
     }
 }
 
-/// Epoch config is representation of [`dkg::DkgOutput`] where QUAL nodes are mapped into list of [`EpochNode`].
+/// Epoch config is representation of [`dkg::DkgOutput`]
+/// where QUAL nodes are mapped into list of [`EpochNode`].
 pub struct EpochConfig<S: Scheme> {
     share: dkg::DistKeyShare<S>,
     remote_nodes: Vec<EpochNode<S>>,

src/chain/handler.rs

@@ -1,3 +1,5 @@
+//! Chain logic implementation.
+//! Price for some abstraction boundaries is traded for speed.
 use super::{
     cache,
     epoch::{EpochConfig, EpochNode},
@@ -39,6 +41,7 @@ use tokio::{
 use tokio_util::task::TaskTracker;
 use tonic::Status;
 
+/// Truncated signature bytes for compact log output.
 const SHORT_SIG_BYTES: usize = 3;
 
 #[derive(thiserror::Error, Debug)]
@@ -53,8 +56,8 @@ pub enum ChainError {
     TickerClosedTx,
     #[error("pool receiver has been closed unexpectedly")]
     PoolClosedRx,
-    #[error("invalid lengh of partial: expected {expected} received {received}")]
-    InvalidShareLenght { expected: usize, received: usize },
+    #[error("invalid length of partial: expected {expected} received {received}")]
+    InvalidShareLength { expected: usize, received: usize },
     #[error("attempt to process beacon from node of index {0}, but it was not in the group file")]
     UnknownIndex(u32),
     #[error("received partial with invalid signature")]
@@ -68,11 +71,11 @@ pub enum ChainError {
     #[error("recovered signature is invalid")]
     InvalidRecovered,
     #[error("chain store: {0}")]
-    ChainStoreError(#[from] StoreError),
+    ChainStore(#[from] StoreError),
     #[error("t_bls: {0}")]
     TBlsError(#[from] tbls::TBlsError),
     #[error("fs: {0}")]
-    FileStoreError(#[from] FileStoreError),
+    FileStore(#[from] FileStoreError),
     #[error("recover_unchecked: scalar is non-invertable")]
     NonInvertableScalar,
     #[error("internal error")]
@@ -85,7 +88,7 @@ pub enum ChainError {
 struct ChainHandler<S: Scheme, B: BeaconRepr> {
     /// Public information of chain.
     chain_info: ChainInfo<S>,
-    /// Minimum period allowed between and subsequent partial generation.
+    /// Minimum period allowed between subsequent partial generation.
     catchup_period: Duration,
     /// Actor handle for beacon persistent database.
     store: ChainStore<B>,
@@ -97,19 +100,20 @@ struct ChainHandler<S: Scheme, B: BeaconRepr> {
     ec: EpochConfig<S>,
     /// Private binding address.
     private_listen: String,
-    /// Public URI Authority.
-    our_addres: Address,
+    /// Public URI authority.
+    our_address: Address,
     log: Logger,
 }
 
 pub enum ChainCmd {
     Shutdown(Callback<(), ChainError>),
-    /// Chain is notified once DKG output is received, triggering preparation
+    /// Notification once DKG output is received, triggers preparation
     /// for transition into the next epoch (see: [`wait_last_round`]).
     NewEpoch {
         first_round: u64,
     },
-    /// Partial reload of the chain module during transition to update [`EpochConfig`] and logger.
+    /// Partially reloads the chain module during transitions to update
+    /// the [`EpochConfig`] and metadata for logger.
     Reload,
     /// Request for chain public information.
     ChainInfo(Callback<ChainInfoPacket, BeaconProcessError>),
@@ -151,8 +155,8 @@ pub struct ChainConfig<B: BeaconRepr> {
 }
 
 impl<S: Scheme, B: BeaconRepr> ChainHandler<S, B> {
-    /// This function updates the epoch configuration and logger for chain handler
-    /// after each DKG.
+    /// This function updates the epoch configuration and logger metadata
+    /// for chain handler after each DKG.
     ///
     /// Returns top-level components of chain module with their channels:
     /// - Chain configuration: [`ChainHandler`].
@@ -211,8 +215,8 @@ impl<S: Scheme, B: BeaconRepr> ChainHandler<S, B> {
             genesis_time,
             genesis_seed,
         };
-        let catchup_period = Duration::from_secs(catchup_period.get_value().into());
 
+        let catchup_period = Duration::from_secs(catchup_period.get_value().into());
         let chain_handler = Self {
             chain_info,
             catchup_period,
@@ -221,12 +225,11 @@ impl<S: Scheme, B: BeaconRepr> ChainHandler<S, B> {
             fs,
             ec,
             private_listen,
-            our_addres,
+            our_address: our_addres,
             log,
         };
 
         let latest_stored = chain_handler.store.last().await?;
-
         let registry = Registry::new(
             &chain_handler.chain_info,
             latest_stored,
@@ -239,9 +242,6 @@ impl<S: Scheme, B: BeaconRepr> ChainHandler<S, B> {
     }
 
     /// Adds remote nodes to connection pool for given beacon ID.
-    ///
-    /// If some nodes are already in pool (registered for other ID),
-    /// their connections will be reused.
     async fn register_in_pool(&self) -> Result<(), ChainError> {
         let peers = self
             .ec
@@ -315,7 +315,7 @@ impl<S: Scheme, B: BeaconRepr> ChainHandler<S, B> {
         {
             if let Some(thr_sigs) =
                 reg.cache_mut()
-                    .add_prechecked(sigshare, &self.our_addres, &self.log)
+                    .add_prechecked(sigshare, &self.our_address, &self.log)
             {
                 let Ok(recovered) = tbls::recover_unchecked(thr_sigs) else {
                     return Err(ChainError::NonInvertableScalar);
@@ -403,7 +403,7 @@ impl<S: Scheme, B: BeaconRepr> ChainHandler<S, B> {
         // Add packet to cache if p_round hits the allowed range and signature is not duplicated.
         if p_round > ls_round + 1 && p_round <= ls_round + 1 + cache::CACHE_LIMIT_ROUNDS {
             let Some(is_added) = reg.cache_mut().add_packet(partial.packet) else {
-                error!(&self.log, "cache_height {}: attempt to add non-allowed round {p_round}, current {c_round}, please report this.", reg.cache().height());
+                error!(&self.log, "cache_height {}: attempt to add non-allowed round {p_round}, current {c_round}, please report this", reg.cache().height());
                 return Err(ChainError::InvalidRound {
                     invalid: p_round,
                     current: c_round,
@@ -423,7 +423,7 @@ impl<S: Scheme, B: BeaconRepr> ChainHandler<S, B> {
         // Process packet as sigshare.
         } else if p_round == ls_round + 1 {
             let Some(idx) = cache::get_partial_index::<S>(&partial.packet.partial_sig) else {
-                return Err(ChainError::InvalidShareLenght {
+                return Err(ChainError::InvalidShareLength {
                     expected: <S::Sig as energon::traits::Group>::POINT_SIZE + 2,
                     received: partial.packet.partial_sig.len(),
                 });
@@ -855,7 +855,7 @@ async fn run_chain<S: Scheme, B: BeaconRepr>(
         private_listen: h.private_listen,
         id: h.chain_info.beacon_id,
         fs: h.fs,
-        our_addres: h.our_addres,
+        our_addres: h.our_address,
     };
 
     Ok(Some(config_for_next_epoch))

src/chain/info.rs

@@ -7,7 +7,8 @@ use crate::{
 use energon::{points::KeyPoint, traits::Affine};
 use sha2::Digest;
 
-/// Public information that is necessary for a client to verify any beacon present in a randomness chain.
+/// Public information that is necessary for a client
+/// to verify any beacon present in a randomness chain.
 #[derive(Default, Clone, PartialEq)]
 pub struct ChainInfo<S: Scheme> {
     pub public_key: KeyPoint<S>,
@@ -24,7 +25,7 @@ pub enum ChainInfoError {
     Scheme,
     #[error("failed to deserialize group key")]
     PublicKey,
-    #[error("genesis time can not be zero")]
+    #[error("genesis time cannot be zero")]
     GenesisTime,
 }
 

src/chain/registry.rs

@@ -6,7 +6,7 @@ use crate::{error, key::Scheme, log::Logger, net::utils::Seconds, protobuf::dran
 use std::time::Duration;
 use tokio::{sync::mpsc, task::JoinHandle};
 
-/// Registry holds actual data which might be changed per / within a round.
+/// Registry holds mutable state that can change each round or during a round.
 pub struct Registry<S: Scheme, B: BeaconRepr> {
     /// Latest verified and successfully stored beacon.
     latest_stored: B,

src/chain/time.rs

@@ -62,24 +62,16 @@ pub fn time_now() -> Duration {
 #[cfg(test)]
 mod test {
     use super::*;
-    fn current_round_t(now: u64, period: u32, genesis: u64) -> u64 {
-        let (next_round, _) = next_round(now, period, genesis);
-        if next_round <= 1 {
-            next_round
-        } else {
-            next_round - 1
-        }
-    }
 
     #[test]
     fn time_basic() {
         let period = 3;
         let round = 22;
         let transition_round = round + ROUNDS_UNTIL_TRANSITION;
 
-        assert_eq!(round, current_round_t(1745308647, period, 1745308582));
-        assert_eq!(round, current_round_t(1745308824, period, 1745308759));
-        assert_eq!(round, current_round_t(1745309210, period, 1745309145));
+        assert_eq!(round, current_round(1745308647, period, 1745308582));
+        assert_eq!(round, current_round(1745308824, period, 1745308759));
+        assert_eq!(round, current_round(1745309210, period, 1745309145));
         assert!(1745308675 == time_of_round(period, 1745308582, transition_round));
         assert!(1745308852 == time_of_round(period, 1745308759, transition_round));
         assert!(1745309238 == time_of_round(period, 1745309145, transition_round));