Fix all the warnings

Author: cowlicks

src/error.rs

@@ -1,20 +1,20 @@
+/// Error type for this crate
 #[derive(Debug, thiserror::Error)]
 pub enum Error {
+    /// Error from the [`snow`] crate
     #[error("Error from `snow`: {0}")]
     Snow(#[from] snow::Error),
+    /// Error from [`crypto_secretstream`] crate
     #[error("Error from `crypto_secretstream`: {0}")]
     SecretStream(crypto_secretstream::aead::Error),
+    /// [`crate::sstream::statemachine::Manager`] handshake invalid state. TODO remove with
+    /// statemachine?
     #[error("Invalid Handshake State: {0}")]
     InvalidHandshakeState(String),
-    // TODO added by claude
-    #[error("Invalid Encryption Statemachine State: {0}")]
-    InvalidState(String),
-    // TODO added by claude
-    #[error("IoError: {0}")]
-    IoError(String),
-    // Missing IO
+    /// Missing IO in [`crate::sstream::sm2::Machine`]
     #[error("Machine IO is not set.")]
     NoIoSetError,
+    /// Error from [`std::io`]
     #[error("{0}")]
     StdIoError(#[from] std::io::Error),
 }

src/sstream/mod.rs

@@ -146,8 +146,8 @@ impl Debug for Ready {
             .finish()
     }
 }
-
 pub mod hc_specific {
+    //! Stuff for generating Hypercore specific things like Noise parameters, keys, etc
     use std::sync::LazyLock;
 
     use snow::{
@@ -163,7 +163,6 @@ pub mod hc_specific {
     static NOISE_PARAMS: LazyLock<NoiseParams> = LazyLock::new(|| {
         NoiseParams::new(
             PARAM_STR.to_string(),
-            //PARAMS.to_string(),
             BaseChoice::Noise,
             HandshakeChoice {
                 pattern: HandshakePattern::IK,

src/sstream/sm2.rs

@@ -1,3 +1,4 @@
+//! Interface for an encrypted channel
 use std::{
     collections::VecDeque,
     fmt::Debug,
@@ -198,15 +199,18 @@ impl SansIoMachine {
         Ok(made_progress.then_some(()))
     }
 
+    #[allow(unused, reason = "vectorized version of 'get_next_sendable_message'")]
     fn get_sendable_messages(&mut self) -> Result<Vec<Vec<u8>>, IoError> {
         self.poll_all_enc_dec()?;
         Ok(self.encrypted_tx.drain(..).collect())
     }
+
     fn get_next_sendable_message(&mut self) -> Result<Option<Vec<u8>>, IoError> {
         self.poll_all_enc_dec()?;
         Ok(self.encrypted_tx.pop_front())
     }
 
+    #[allow(unused, reason = "vectorized version of 'receive_next'")]
     fn receive_next_messages(&mut self, encrypted_messages: Vec<Vec<u8>>) {
         self.encrypted_rx
             .extend(encrypted_messages.into_iter().map(Ok));
@@ -216,6 +220,7 @@ impl SansIoMachine {
         self.encrypted_rx.push_back(Ok(encrypted_msg));
     }
 
+    #[allow(unused, reason = "add a new plaintext message to send")]
     fn queue_msg(&mut self, msg: Vec<u8>) {
         self.plain_tx.push_back(msg);
     }
@@ -243,12 +248,17 @@ impl Debug for SansIoMachine {
 }
 
 #[derive(Debug)]
+/// Encryption event
 pub enum Event {
+    /// Data passed through the handshake payload
     HandshakePayload(Vec<u8>),
+    /// Decrypted message
     Message(Vec<u8>),
+    /// Error occured in encryption
     ErrStuff(IoError),
 }
 
+/// Supertrait for duplex channel required by [`Machine`]
 pub trait MachineIo:
     Stream<Item = Result<Vec<u8>, IoError>> + Sink<Vec<u8>> + Send + Unpin + 'static
 {
@@ -277,6 +287,12 @@ impl Debug for Machine {
 }
 
 impl Machine {
+    /// Create a new [`Machine`]
+    fn new(io: Option<Box<dyn MachineIo<Error = std::io::Error>>>, inner: SansIoMachine) -> Self {
+        Self { io, inner }
+    }
+
+    /// Create a new initiator
     pub fn new_dht_init(
         io: Option<Box<dyn MachineIo<Error = std::io::Error>>>,
         remote_pub_key: &[u8; PUBLIC_KEYLEN],
@@ -285,44 +301,38 @@ impl Machine {
         let ss = SecStream::new_initiator(remote_pub_key, prologue)?;
         let state = State::InitiatorStart(ss);
         let inner = SansIoMachine::new(state);
-        Ok(Self { io, inner })
+        Ok(Self::new(io, inner))
+    }
+
+    /// Create a new initiator
+    pub fn new_init(
+        io: Box<dyn MachineIo<Error = std::io::Error>>,
+        state: SecStream<Initiator<Start>>,
+    ) -> Self {
+        Self::new(Some(io), SansIoMachine::new_init(state))
     }
 
-    fn new_dht_resp(
+    /// Create a new responder from a private key
+    pub fn resp_from_private(
         io: Option<Box<dyn MachineIo<Error = std::io::Error>>>,
         private: &[u8],
     ) -> Result<Self, Error> {
         let ss = SecStream::new_responder(private)?;
         let state = State::RespStart(ss);
         let inner = SansIoMachine::new(state);
-        Ok(Self { io, inner })
+        Ok(Self::new(io, inner))
     }
 
-    fn new(io: Option<Box<dyn MachineIo<Error = std::io::Error>>>, inner: SansIoMachine) -> Self {
-        Self { io, inner }
-    }
-
-    fn new_init(
-        io: Box<dyn MachineIo<Error = std::io::Error>>,
-        state: SecStream<Initiator<Start>>,
-    ) -> Self {
-        Self {
-            io: Some(io),
-            inner: SansIoMachine::new_init(state),
-        }
-    }
-
-    fn new_resp(
+    /// Create a new responder
+    pub fn new_resp(
         io: Box<dyn MachineIo<Error = std::io::Error>>,
         state: SecStream<Responder<Start>>,
     ) -> Self {
-        Self {
-            io: Some(io),
-            inner: SansIoMachine::new_resp(state),
-        }
+        Self::new(Some(io), SansIoMachine::new_resp(state))
     }
 
-    async fn complete_handshake(&mut self) -> Result<(), IoError> {
+    /// Wait for handshake to complete
+    pub async fn complete_handshake(&mut self) -> Result<(), IoError> {
         use futures::SinkExt;
         use futures::StreamExt;