From 79a74ed2a5728592821f0b6e290ec878459af558 Mon Sep 17 00:00:00 2001
From: "Dr. Capybara" <dustinray313@gmail.com>
Date: Mon, 16 Oct 2023 20:59:39 -0700
Subject: [PATCH] docs

---
 README.md  | 59 +++++++++++++++++++++++++++---------------------------
 src/ops.rs |  8 +++-----
 2 files changed, 33 insertions(+), 34 deletions(-)

diff --git a/README.md b/README.md
index 6ab6585..495e1d2 100644
--- a/README.md
+++ b/README.md
@@ -46,54 +46,55 @@ assert!(hex::encode(data.digest.unwrap().to_vec()) == expected);
 
 ### Symmetric Encrypt/Decrypt:
 ```rust
-use capycrypt::{Message, PwEncryptable};
-use capycrypt::sha3::{aux_functions::{byte_utils::{get_random_bytes}}};
+use capycrypt::{
+    Message,
+    PwEncryptable,
+    sha3::{aux_functions::{byte_utils::{get_random_bytes}}}
+};
 // Get a random password
-let pw = get_random_bytes(64); 
+let pw = get_random_bytes(64);
 // Get 5mb random data
-let mut msg = Message::new(&mut get_random_bytes(5242880));  
-
+let mut msg = Message::new(&mut get_random_bytes(5242880));
 // Encrypt the data with 512 bits of security
-msg.pw_encrypt(&mut pw.clone(), 512); 
+msg.pw_encrypt(&mut pw.clone(), 512);
 // Decrypt the data
-msg.pw_decrypt(&mut pw.clone(), 512); 
+msg.pw_decrypt(&mut pw.clone(), 512);
 // Verify operation success
-assert!(msg.op_result.unwrap()); 
+assert!(msg.op_result.unwrap());
 ```
 
 ### Asymmetric Encrypt/Decrypt:
 ```rust
-use capycrypt::{Message, KeyEncryptable};
-use capycrypt::sha3::{aux_functions::{byte_utils::{get_random_bytes}}};
-// 5mb random data
+use capycrypt::{
+    KeyEncryptable,
+    KeyPair,
+    Message,
+    sha3::aux_functions::byte_utils::get_random_bytes,
+    curves::EdCurves::E448};
+// Get 5mb random data
 let mut msg = Message::new(&mut get_random_bytes(5242880));
-// Generate a private/public keypair
-let key_pair = KeyPair::new(&get_random_bytes(32), "test key".to_string(), E448, 256);
-
-// Encrypt with public key with 256 bits of security
-msg.key_encrypt(&key_pair.pub_key, 256);
-// Decrypt with private key
-msg.key_decrypt(&key_pair.priv_key, 256);
-// Verify correct decryption
-assert!(msg.op_result.unwrap());
+// Generate the keypair
+let key_pair = KeyPair::new(&get_random_bytes(32), "test key".to_string(), E448, 512);
+// Encrypt with the public key
+msg.key_encrypt(&key_pair.pub_key, 512);
 ```
 
 ### Schnorr Signatures:
 ```rust
-use capycrypt::{KeyPair, Message, Signable};
-use capycrypt::sha3::{aux_functions::{byte_utils::{get_random_bytes}}};
+use capycrypt::{
+    Signable,
+    KeyPair,
+    Message,
+    sha3::aux_functions::byte_utils::get_random_bytes,
+    curves::EdCurves::E448};
 // Get random 5mb
 let mut msg = Message::new(&mut get_random_bytes(5242880));
 // Get a random password
 let pw = get_random_bytes(64);
-// Generate a public/private keypair
-let mut key_pair = KeyPair::new(&pw, "Key Tester".to_string(), E448, 512);
-
-// Sign the message with the private key
+// Generate a signing keypair
+let key_pair = KeyPair::new(&pw, "test key".to_string(), E448, 512);
+// Sign with 512 bits of security
 msg.sign(&key_pair, 512);
-// Verify the message with the public key
-msg.verify(&key_pair.pub_key, 512);
-assert!(msg.op_result.unwrap());
 ```
 
 ## Benches
diff --git a/src/ops.rs b/src/ops.rs
index 0ef92f7..8b19019 100644
--- a/src/ops.rs
+++ b/src/ops.rs
@@ -97,9 +97,6 @@ pub fn cshake(x: &mut Vec<u8>, l: u64, n: &str, s: &str, d: u64) -> Vec<u8> {
 ///
 /// ## Returns:
 /// * `return  -> Vec<u8>`: kmac_xof of `x` under `k`
-/// ## Usage:
-/// ```
-/// ```
 pub fn kmac_xof(k: &Vec<u8>, x: &Vec<u8>, l: u64, s: &str, d: u64) -> Vec<u8> {
     let mut encode_k = encode_string(k);
     let bytepad_w = match d {
@@ -327,10 +324,11 @@ impl KeyEncryptable for Message {
     ///     Message,
     ///     sha3::aux_functions::byte_utils::get_random_bytes,
     ///     curves::EdCurves::E448};
-    ///
+    /// // Get 5mb random data
     /// let mut msg = Message::new(&mut get_random_bytes(5242880));
+    /// // Generate the keypair
     /// let key_pair = KeyPair::new(&get_random_bytes(32), "test key".to_string(), E448, 512);
-    ///
+    /// // Encrypt with the public key
     /// msg.key_encrypt(&key_pair.pub_key, 512);
     /// ```
     fn key_encrypt(&mut self, pub_key: &EdCurvePoint, d: u64) {