diff --git a/src/agreement.rs b/src/agreement.rs
index c5687df..42951a5 100644
--- a/src/agreement.rs
+++ b/src/agreement.rs
@@ -27,10 +27,10 @@ impl Agreement {
 }
 
 impl crate::Sendable for Agreement {
-    fn to_packet(&self, encrypt_kind: crate::EncryptKind) -> Result<Packet> {
+    fn to_packet(&self, encrypt_flag: crate::EncryptFlag) -> Result<Packet> {
         let contents: Vec<u8> = serde_json::to_string(&self)?.into_bytes();
         let kind = 0xff;
-        Ok(Packet::new(kind, contents, encrypt_kind))
+        Ok(Packet::new(kind, contents, encrypt_flag))
     }
 
     fn from_packet(packet: Packet) -> Result<Self> {
diff --git a/src/encrypt.rs b/src/encrypt.rs
index 5b4889a..b23562a 100644
--- a/src/encrypt.rs
+++ b/src/encrypt.rs
@@ -7,7 +7,7 @@ use ring::digest;
 /// trait that allows for me to be lazy
 pub trait Encryption {
     /// return the encryption kind
-    fn kind(&self) -> EncryptKind;
+    fn kind(&self) -> EncryptFlag;
     /// returns Option<SecretKey>
     fn key(&self) -> Option<&SecretKey>;
     /// encrypts the packet contents and updates the integrity hash
@@ -21,8 +21,8 @@ pub trait Encryption {
 pub struct SymmetricEncrypt(SecretKey);
 
 impl Encryption for SymmetricEncrypt {
-    fn kind(&self) -> EncryptKind {
-        EncryptKind::Symmetric
+    fn kind(&self) -> EncryptFlag {
+        EncryptFlag::Symmetric
     }
 
     fn key(&self) -> Option<&SecretKey> {
@@ -69,8 +69,8 @@ impl NoEncrypt {
 }
 
 impl Encryption for NoEncrypt {
-    fn kind(&self) -> EncryptKind {
-        EncryptKind::None
+    fn kind(&self) -> EncryptFlag {
+        EncryptFlag::None
     }
 
     // lol
@@ -92,17 +92,17 @@ impl Encryption for NoEncrypt {
 /// encryption kind
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 #[repr(u8)]
-pub enum EncryptKind {
+pub enum EncryptFlag {
     None = 0x00,
     Symmetric = 0xff,
 }
 
-impl EncryptKind {
-    /// returns `EncryptKind` from u8 if returned value is valid
-    pub fn from_u8(kind: u8) -> Option<EncryptKind> {
+impl EncryptFlag {
+    /// returns `EncryptFlag` from u8 if returned value is valid
+    pub fn from_u8(kind: u8) -> Option<EncryptFlag> {
         match kind {
-            0x00 => Some(EncryptKind::None),
-            0xff => Some(EncryptKind::Symmetric),
+            0x00 => Some(EncryptFlag::None),
+            0xff => Some(EncryptFlag::Symmetric),
             _ => None,
         }
     }
diff --git a/src/lib.rs b/src/lib.rs
index d9809f7..4eef5f8 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -24,7 +24,7 @@ pub use agreement::Agreement;
 pub mod encrypt;
 
 // namespacing
-use encrypt::{EncryptKind, Encryption};
+use encrypt::{EncryptFlag, Encryption};
 use futures_util::io::{AsyncReadExt, AsyncWriteExt};
 use orion::aead;
 use ring::{agreement as agree, digest, rand};
@@ -41,7 +41,7 @@ struct NetworkPacket(Vec<u8>);
 /// a type of data that can be sent
 pub trait Sendable: Sized {
     /// create a packet from the struct
-    fn to_packet(&self, encrypt_flag: EncryptKind) -> Result<Packet>;
+    fn to_packet(&self, encrypt_flag: EncryptFlag) -> Result<Packet>;
     /// create the struct from a packet
     fn from_packet(packet: Packet) -> Result<Self>;
     /// returns the sendable's packet kind
@@ -52,14 +52,14 @@ pub trait Sendable: Sized {
 #[derive(Debug, Clone)]
 pub struct Packet {
     pub kind: u8,
-    pub encrypt_flag: EncryptKind,
+    pub encrypt_flag: EncryptFlag,
     pub integrity_hash: Vec<u8>,
     pub contents: Vec<u8>,
 }
 
 impl Packet {
     /// create a new `Packet`
-    pub fn new(kind: u8, contents: Vec<u8>, encrypt_flag: EncryptKind) -> Packet {
+    pub fn new(kind: u8, contents: Vec<u8>, encrypt_flag: EncryptFlag) -> Packet {
         let integrity_hash = digest::digest(&digest::SHA256, &contents).as_ref().to_vec();
         Packet {
             kind,
@@ -189,7 +189,7 @@ where
     }
 
     let kind = info_buf[0];
-    let encrypt_flag = EncryptKind::from_u8(info_buf[1]).unwrap();
+    let encrypt_flag = EncryptFlag::from_u8(info_buf[1]).unwrap();
     let length = u64::from_le_bytes(info_buf[2..10].try_into().unwrap()) as usize;
     let checksum = u32::from_le_bytes(info_buf[10..14].try_into().unwrap());
 
@@ -209,7 +209,7 @@ where
     packet.verify_checksum(checksum)?;
     packet.verify_integrity()?;
 
-    if packet.encrypt_flag == EncryptKind::Symmetric {
+    if packet.encrypt_flag == EncryptFlag::Symmetric {
         encryption.decrypt(&mut packet)?;
     }
     Ok(Some(packet))
@@ -223,12 +223,12 @@ where
     E: Encryption,
 {
     match encryption.kind() {
-        EncryptKind::None => {
+        EncryptFlag::None => {
             let network_packet = packet.to_packet(encryption.kind())?.to_network_packet();
             stream.write(&network_packet.0).await?;
             Ok(())
         }
-        EncryptKind::Symmetric => {
+        EncryptFlag::Symmetric => {
             let mut packet = packet.to_packet(encryption.kind())?;
             encryption.encrypt(&mut packet)?;
             let network_packet = packet.to_network_packet();
@@ -245,12 +245,12 @@ where
     E: Encryption,
 {
     match encryption.kind() {
-        EncryptKind::None => {
+        EncryptFlag::None => {
             let network_packet = packet.to_network_packet();
             stream.write(&network_packet.0).await?;
             Ok(())
         }
-        EncryptKind::Symmetric => {
+        EncryptFlag::Symmetric => {
             let mut packet = packet;
             encryption.encrypt(&mut packet)?;
             let network_packet = packet.to_network_packet();
diff --git a/src/message.rs b/src/message.rs
index bf725a7..d3e4b21 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -28,10 +28,10 @@ impl Message {
 }
 
 impl crate::Sendable for Message {
-    fn to_packet(&self, encrypt_kind: crate::EncryptKind) -> Result<Packet> {
+    fn to_packet(&self, encrypt_flag: crate::EncryptFlag) -> Result<Packet> {
         let contents: Vec<u8> = serde_json::to_string(&self)?.into_bytes();
         let kind = 0x00;
-        Ok(Packet::new(kind, contents, encrypt_kind))
+        Ok(Packet::new(kind, contents, encrypt_flag))
     }
 
     fn from_packet(packet: Packet) -> Result<Self> {