diff --git a/src/handshake.rs b/src/handshake.rs
index 36a77b8..6b56519 100644
--- a/src/handshake.rs
+++ b/src/handshake.rs
@@ -13,7 +13,7 @@ use zeroize::Zeroize;
 
 use crate::{
     Role, WHARRGHARBL_PROTO,
-    transport::{AeadNeko, AeadTranport},
+    transport::{AeadNeko, AeadTransport},
 };
 
 pub struct ClientHandshake<S: NekoSec, K: Kem + ParameterSet> {
@@ -58,7 +58,7 @@ where
         Ok(())
     }
 
-    pub fn receive(&mut self, ciphertext: &[u8]) -> aead::Result<AeadTranport<S>> {
+    pub fn receive(&mut self, ciphertext: &[u8]) -> aead::Result<AeadTransport<S>> {
         let decap = self.decap.as_ref().ok_or(aead::Error)?;
 
         let tag = ciphertext
@@ -80,7 +80,7 @@ where
         Ok(self.finish(shared))
     }
 
-    fn finish(&mut self, mut shared: SharedKey) -> AeadTranport<S> {
+    fn finish(&mut self, mut shared: SharedKey) -> AeadTransport<S> {
         self.neko.key(&shared);
         shared.zeroize();
 
@@ -95,7 +95,7 @@ where
 
         entropy.zeroize();
 
-        AeadTranport::new(key, outbound, inbound, Role::Sender)
+        AeadTransport::new(key, outbound, inbound, Role::Sender)
     }
 }
 
@@ -126,7 +126,7 @@ impl<S: NekoSec, K: Kem<SharedKeySize = U32> + ParameterSet> ServerHandshake<S,
         &mut self,
         rng: &mut impl CryptoRng,
         buf: &mut dyn Buffer,
-    ) -> aead::Result<AeadTranport<S>> {
+    ) -> aead::Result<AeadTransport<S>> {
         let slice = buf.as_ref();
 
         let tag = slice
@@ -154,7 +154,7 @@ impl<S: NekoSec, K: Kem<SharedKeySize = U32> + ParameterSet> ServerHandshake<S,
         Ok(self.finish(shared))
     }
 
-    fn finish(&mut self, mut shared: SharedKey) -> AeadTranport<S> {
+    fn finish(&mut self, mut shared: SharedKey) -> AeadTransport<S> {
         self.neko.key(&shared);
         shared.zeroize();
 
@@ -169,7 +169,7 @@ impl<S: NekoSec, K: Kem<SharedKeySize = U32> + ParameterSet> ServerHandshake<S,
 
         entropy.zeroize();
 
-        AeadTranport::new(key, outbound, inbound, Role::Receiver)
+        AeadTransport::new(key, outbound, inbound, Role::Receiver)
     }
 }
 
diff --git a/src/transport.rs b/src/transport.rs
index 15180c8..29eded0 100644
--- a/src/transport.rs
+++ b/src/transport.rs
@@ -72,14 +72,14 @@ impl<S: NekoSec> zeroize::Zeroize for AeadNeko<S> {
     }
 }
 
-pub struct AeadTranport<S: NekoSec> {
+pub struct AeadTransport<S: NekoSec> {
     pub(crate) aead: AeadNeko<S>,
     pub(crate) epstein: aead::Nonce<AeadNeko<S>>,
     pub(crate) trump: aead::Nonce<AeadNeko<S>>,
     handshake_role: Role,
 }
 
-impl<S: NekoSec> zeroize::Zeroize for AeadTranport<S> {
+impl<S: NekoSec> zeroize::Zeroize for AeadTransport<S> {
     fn zeroize(&mut self) {
         self.aead.zeroize();
         self.epstein.zeroize();
@@ -87,15 +87,15 @@ impl<S: NekoSec> zeroize::Zeroize for AeadTranport<S> {
     }
 }
 
-impl<S: NekoSec> zeroize::ZeroizeOnDrop for AeadTranport<S> {}
+impl<S: NekoSec> zeroize::ZeroizeOnDrop for AeadTransport<S> {}
 
-impl<S: NekoSec> Drop for AeadTranport<S> {
+impl<S: NekoSec> Drop for AeadTransport<S> {
     fn drop(&mut self) {
         zeroize::Zeroize::zeroize(self);
     }
 }
 
-impl<S: NekoSec> AeadTranport<S> {
+impl<S: NekoSec> AeadTransport<S> {
     pub(crate) fn new(
         key: Key<AeadNeko<S>>,
         outbound: aead::Nonce<AeadNeko<S>>,
@@ -152,7 +152,7 @@ impl<S: NekoSec> AeadTranport<S> {
 }
 
 pub struct SendState<'a, S: NekoSec> {
-    transport: &'a AeadTranport<S>,
+    transport: &'a AeadTransport<S>,
     counter: u64,
 }
 
@@ -174,7 +174,7 @@ impl<S: NekoSec> SendState<'_, S> {
 }
 
 pub struct RecvState<'a, S: NekoSec> {
-    transport: &'a AeadTranport<S>,
+    transport: &'a AeadTransport<S>,
     counter: u64,
 }
 
@@ -213,13 +213,13 @@ mod tests {
         let outbound = 123u128.to_ne_bytes();
         let inbound = 234u128.to_ne_bytes();
 
-        let alice = AeadTranport::<Neko128>::new(
+        let alice = AeadTransport::<Neko128>::new(
             shared_secret.into(),
             outbound.into(),
             inbound.into(),
             Role::Sender,
         );
-        let bob = AeadTranport::<Neko128>::new(
+        let bob = AeadTransport::<Neko128>::new(
             shared_secret.into(),
             outbound.into(),
             inbound.into(),
@@ -286,13 +286,13 @@ mod tests {
         let outbound = 123u128.to_ne_bytes();
         let inbound = 234u128.to_ne_bytes();
 
-        let alice = AeadTranport::<Neko128>::new(
+        let alice = AeadTransport::<Neko128>::new(
             shared_secret.into(),
             outbound.into(),
             inbound.into(),
             Role::Sender,
         );
-        let bob = AeadTranport::<Neko256>::new(
+        let bob = AeadTransport::<Neko256>::new(
             shared_secret.into(),
             outbound.into(),
             inbound.into(),
diff --git a/wharrgarbl-neko/src/lib.rs b/wharrgarbl-neko/src/lib.rs
index 832c0a9..85cefce 100644
--- a/wharrgarbl-neko/src/lib.rs
+++ b/wharrgarbl-neko/src/lib.rs
@@ -167,26 +167,29 @@ impl<Sec: NekoSec> NekoState<Sec> {
         self.position += ratchet_bytes;
     }
 
+    /// Sets a provided key into the cipher state.
     pub fn key(&mut self, data: &NekoKey<Sec>) {
         self.begin_op(ops::KEY);
 
         self.overwrite(data);
     }
 
+    /// Absorbs a nonce value into the cipher state
     pub fn nonce(&mut self, data: &NekoNonce) {
         self.begin_op(ops::NONCE);
 
         self.absorb(data);
     }
 
-    /// Absorb associated data into the cipher. This should include a nonce at least,
-    /// along with other data coming from the app.
+    /// Absorb associated data into the cipher.
     pub fn ad(&mut self, data: &[u8]) {
         self.begin_op(ops::AD);
 
         self.absorb(data);
     }
 
+    /// Pseudo-random Function. Used to generate new keys/nonces from the
+    /// cipher state.
     pub fn prf(&mut self, data: &mut [u8]) {
         self.begin_op(ops::PRF);
 
@@ -195,6 +198,8 @@ impl<Sec: NekoSec> NekoState<Sec> {
         self.squeeze(data);
     }
 
+    /// Create a message authentication code (MAC). This is used to validate the resulting
+    /// state after ingesting/encrypting data.
     pub fn create_mac(&mut self) -> NekoTag {
         self.begin_op(ops::MAC);
 
@@ -207,6 +212,9 @@ impl<Sec: NekoSec> NekoState<Sec> {
         tag
     }
 
+    /// Validates a provided MAC. After ingesting/decrypting data, the resulting state
+    /// of the cipher should be the same as the sender's. The MAC validates that this
+    /// is correct. Any differences in length/bits/etc, should result in an invalid MAC.
     pub fn verify_mac(&mut self, data: &NekoTag) -> aead::Result<()> {
         self.begin_op(ops::MAC);
 
@@ -225,6 +233,7 @@ impl<Sec: NekoSec> NekoState<Sec> {
         }
     }
 
+    /// Takes a cleartext buffer, and encrypts it in place.
     pub fn encrypt(&mut self, data: &mut [u8]) {
         self.begin_op(ops::ENC);
 
@@ -233,6 +242,7 @@ impl<Sec: NekoSec> NekoState<Sec> {
         self.absorb_and_set(data);
     }
 
+    /// Takes a ciphertext buffer, and decrypts it in place.
     pub fn decrypt(&mut self, data: &mut [u8]) {
         self.begin_op(ops::ENC);
 
@@ -252,6 +262,8 @@ impl<Sec: NekoSec> NekoState<Sec> {
         self.absorb(data);
     }
 
+    /// Permutes and zeros a portion of the cipher state in order to provide forward secrecy.
+    /// The amount of bits zeroed is dependent on the cipher strength (128/256).
     pub fn ratchet(&mut self) {
         self.begin_op(ops::RATCHET);