diff --git a/src/blob.rs b/src/blob.rs
index 199c2d0..a9ce9ef 100644
--- a/src/blob.rs
+++ b/src/blob.rs
@@ -12,7 +12,6 @@ use std::hash::Hash;
 use std::ops::Deref;
 use std::ops::DerefMut;
 
-use serde::ser::SerializeTuple;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use zeroize::Zeroize;
 
@@ -125,14 +124,7 @@ impl<const L: usize> Serialize for Blob<L> {
         if serializer.is_human_readable() {
             base64::to_string(&self.0).serialize(serializer)
         } else {
-            // Serde will alway include a length field in binary formats unless we tell it this type
-            // is specifically a statically sized tuple
-            // This is actually the recommended way to serialize a [u8; _] according to serde's docs
-            let mut tuple = serializer.serialize_tuple(L)?;
-            for b in &self.0 {
-                tuple.serialize_element(b)?;
-            }
-            tuple.end()
+            serializer.serialize_bytes(&self.0)
         }
     }
 }
@@ -167,19 +159,6 @@ impl<'de, const L: usize> serde::de::Visitor<'de> for BlobVisitor<L> {
             .map(|b| Blob::<L>(b))
             .map_err(|_| serde::de::Error::invalid_length(v.len(), &self))
     }
-
-    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-    where
-        A: serde::de::SeqAccess<'de>,
-    {
-        let mut bytes = [0u8; L];
-
-        for i in 0..L {
-            bytes[i] = seq.next_element()?.ok_or_else(|| serde::de::Error::invalid_length(i, &self))?;
-        }
-
-        Ok(Blob(bytes))
-    }
 }
 
 impl<'de, const L: usize> Deserialize<'de> for Blob<L> {
@@ -191,7 +170,7 @@ impl<'de, const L: usize> Deserialize<'de> for Blob<L> {
         if deserializer.is_human_readable() {
             deserializer.deserialize_str(BlobVisitor::<L>)
         } else {
-            deserializer.deserialize_tuple(L, BlobVisitor::<L>)
+            deserializer.deserialize_bytes(BlobVisitor::<L>)
         }
     }
 }