addressed some PR comments

src/lib.rs

@@ -34,7 +34,7 @@ pub fn fetch_chain_info(
     transport: &HttpTransport,
     base_url: &str,
 ) -> Result<ChainInfo, DrandClientError> {
-    let url = format!("{}/info", base_url);
+    let url = format!("{base_url}/info");
     match transport.fetch(&url) {
         Err(_) => Err(DrandClientError::NotResponding),
         Ok(body) => serde_json::from_str(&body).map_err(|e| {
@@ -51,9 +51,10 @@ impl<'a, T: Transport> DrandClient<'a, T> {
 
     pub fn randomness(&self, round_number: u64) -> Result<Beacon, DrandClientError> {
         if round_number == 0 {
-            return Err(InvalidRound);
+            Err(InvalidRound)
+        } else {
+            self.fetch_beacon_tag(&format!("{}", round_number))
         }
-        self.fetch_beacon_tag(&format!("{}", round_number))
     }
 
     fn fetch_beacon_tag(&self, tag: &str) -> Result<Beacon, DrandClientError> {
@@ -111,7 +112,7 @@ mod test {
         let client = new_http_client(chained_url)?;
         let randomness = client.latest_randomness()?;
         assert!(randomness.round_number > 0);
-        return Ok(());
+        Ok(())
     }
 
     #[test]
@@ -120,7 +121,7 @@ mod test {
         let client = new_http_client(unchained_url)?;
         let randomness = client.latest_randomness()?;
         assert!(randomness.round_number > 0);
-        return Ok(());
+        Ok(())
     }
 
     #[test]
@@ -130,7 +131,7 @@ mod test {
         let result = client.randomness(0);
         assert!(result.is_err());
         assert_eq!(result.unwrap_err(), InvalidRound);
-        return Ok(());
+        Ok(())
     }
 
     #[test]

src/verify.rs

@@ -121,10 +121,13 @@ fn chained_beacon_message(beacon: &Beacon) -> Result<Vec<u8>, VerificationError>
     if beacon.previous_signature.is_empty() {
         Err(VerificationError::ChainedBeaconNeedsPreviousSignature)
     } else {
-        // surely there's a better way to concat two slices
-        let mut message = Vec::new();
-        message.extend_from_slice(beacon.previous_signature.as_slice());
-        message.extend_from_slice(&beacon.round_number.to_be_bytes());
+        let message: Vec<u8> = beacon
+            .previous_signature
+            .clone()
+            .into_iter()
+            .chain(beacon.round_number.to_be_bytes().into_iter())
+            .collect();
+
         Ok(Sha256::digest(message.as_slice()).to_vec())
     }
 }
@@ -596,15 +599,15 @@ mod test {
     }
 
     fn dehexify(s: &str) -> Vec<u8> {
-        return hex::decode(s).unwrap().to_vec();
+        hex::decode(s).unwrap().to_vec()
     }
 
     fn assert_error(actual: Result<(), VerificationError>, expected: VerificationError) {
         match actual {
             Ok(_) => panic!("expected error but got success"),
             Err(e) => {
                 if e != expected {
-                    panic!("expected {:?} but got {:?}", expected, e);
+                    panic!("expected {expected:?} but got {e:?}");
                 }
             }
         }