diff --git a/Cargo.lock b/Cargo.lock
index 21dd3f670..de2cf1a0b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -70,12 +70,12 @@ dependencies = [
 [[package]]
 name = "blobby"
 version = "0.4.0-pre.0"
-source = "git+https://github.com/RustCrypto/utils#1227836d92c56dce5fddb3ed36003277f053267b"
+source = "git+https://github.com/RustCrypto/utils#f5ac85f6aa02aa39614f62a6a1add9468be67892"
 
 [[package]]
 name = "block-buffer"
 version = "0.11.0-rc.4"
-source = "git+https://github.com/RustCrypto/utils#6fd0e8ddc827d7e7d9242e130f8944fc9ca328cf"
+source = "git+https://github.com/RustCrypto/utils#f5ac85f6aa02aa39614f62a6a1add9468be67892"
 dependencies = [
  "hybrid-array",
  "zeroize",
@@ -429,9 +429,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.95"
+version = "1.0.96"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
+checksum = "beef09f85ae72cea1ef96ba6870c51e6382ebfa4f0e85b643459331f3daa5be0"
 dependencies = [
  "unicode-ident",
 ]
@@ -508,9 +508,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.141"
+version = "1.0.142"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30b9eff21ebe718216c6ec64e1d9ac57087aad11efc64e32002bce4a0d4c03d3"
+checksum = "030fedb782600dcbd6f02d479bf0d817ac3bb40d644745b769d6a96bc3afc5a7"
 dependencies = [
  "itoa",
  "memchr",
diff --git a/Cargo.toml b/Cargo.toml
index f3ed415c2..7f57fc98b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -20,4 +20,5 @@ signature = { path = "signature" }
 # https://github.com/RustCrypto/utils/pull/1187
 blobby = { git = "https://github.com/RustCrypto/utils" }
 # https://github.com/RustCrypto/utils/pull/1192
+# https://github.com/RustCrypto/utils/pull/1200
 block-buffer = { git = "https://github.com/RustCrypto/utils" }
diff --git a/digest/CHANGELOG.md b/digest/CHANGELOG.md
index a4fe6b64a..c483c46b2 100644
--- a/digest/CHANGELOG.md
+++ b/digest/CHANGELOG.md
@@ -16,6 +16,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Edition changed to 2024 and MSRV bumped to 1.85 ([#1759])
 - `CtVariableCoreWrapper` renamed to `CtOutWrapper` ([#1799])
 - Removed the OID type parameter from `CtOutWrapper` ([#1799])
+- Implementations of the `SerializableState` trait ([#1953])
 
 ### Removed
 - `Mac::new`, `Mac::new_from_slice`, and `Mac::generate_key` methods ([#1173])
@@ -29,6 +30,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 [#1799]: https://github.com/RustCrypto/traits/pull/1799
 [#1809]: https://github.com/RustCrypto/traits/pull/1809
 [#1820]: https://github.com/RustCrypto/traits/pull/1820
+[#1953]: https://github.com/RustCrypto/traits/pull/1953
 
 ## 0.10.7 (2023-05-19)
 ### Changed
diff --git a/digest/src/block_api/ct_variable.rs b/digest/src/block_api/ct_variable.rs
index 775dd3c34..0e6459932 100644
--- a/digest/src/block_api/ct_variable.rs
+++ b/digest/src/block_api/ct_variable.rs
@@ -5,16 +5,12 @@ use super::{
 #[cfg(feature = "mac")]
 use crate::MacMarker;
 use crate::{CollisionResistance, CustomizedInit, HashMarker, VarOutputCustomized};
-use core::{
-    fmt,
-    marker::PhantomData,
-    ops::{Add, Sub},
-};
+use core::{fmt, marker::PhantomData};
 use crypto_common::{
     Block, BlockSizeUser, OutputSizeUser,
     array::{Array, ArraySize},
-    hazmat::{DeserializeStateError, SerializableState, SerializedState, SubSerializedStateSize},
-    typenum::{IsLess, IsLessOrEqual, Le, NonZero, Sum, True, U1, U256},
+    hazmat::{DeserializeStateError, SerializableState, SerializedState},
+    typenum::{IsLessOrEqual, True},
 };
 
 /// Wrapper around [`VariableOutputCore`] which selects output size at compile time.
@@ -177,41 +173,21 @@ where
     }
 }
 
-type CtVariableCoreWrapperSerializedStateSize<T> =
-    Sum<<T as SerializableState>::SerializedStateSize, U1>;
-
 impl<T, OutSize> SerializableState for CtOutWrapper<T, OutSize>
 where
     T: VariableOutputCore + SerializableState,
     OutSize: ArraySize + IsLessOrEqual<T::OutputSize, Output = True>,
-    T::BlockSize: IsLess<U256>,
-    Le<T::BlockSize, U256>: NonZero,
-    T::SerializedStateSize: Add<U1>,
-    CtVariableCoreWrapperSerializedStateSize<T>: Sub<T::SerializedStateSize> + ArraySize,
-    SubSerializedStateSize<CtVariableCoreWrapperSerializedStateSize<T>, T>: ArraySize,
 {
-    type SerializedStateSize = CtVariableCoreWrapperSerializedStateSize<T>;
+    type SerializedStateSize = <T as SerializableState>::SerializedStateSize;
 
     fn serialize(&self) -> SerializedState<Self> {
-        let serialized_inner = self.inner.serialize();
-        let serialized_outsize = Array([OutSize::U8]);
-
-        serialized_inner.concat(serialized_outsize)
+        self.inner.serialize()
     }
 
     fn deserialize(
         serialized_state: &SerializedState<Self>,
     ) -> Result<Self, DeserializeStateError> {
-        let (serialized_inner, serialized_outsize) =
-            serialized_state.split_ref::<T::SerializedStateSize>();
-
-        if serialized_outsize[0] != OutSize::U8 {
-            return Err(DeserializeStateError);
-        }
-
-        Ok(Self {
-            inner: T::deserialize(serialized_inner)?,
-            _out: PhantomData,
-        })
+        let _out = PhantomData;
+        T::deserialize(serialized_state).map(|inner| Self { inner, _out })
     }
 }
diff --git a/digest/src/buffer_macros/fixed.rs b/digest/src/buffer_macros/fixed.rs
index f1e73b641..407581bb3 100644
--- a/digest/src/buffer_macros/fixed.rs
+++ b/digest/src/buffer_macros/fixed.rs
@@ -429,49 +429,33 @@ macro_rules! buffer_fixed {
         impl$(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $crate::crypto_common::hazmat::SerializableState for $name$(< $( $lt ),+ >)? {
             type SerializedStateSize = $crate::typenum::Sum<
                 <$core_ty as $crate::crypto_common::hazmat::SerializableState>::SerializedStateSize,
-                $crate::typenum::Add1<
-                    <$core_ty as $crate::block_api::BlockSizeUser>::BlockSize
+                $crate::block_buffer::SerializedBufferSize<
+                    <$core_ty as $crate::block_api::BlockSizeUser>::BlockSize,
+                    <$core_ty as $crate::block_api::BufferKindUser>::BufferKind,
                 >
             >;
 
             #[inline]
             fn serialize(&self) -> $crate::crypto_common::hazmat::SerializedState<Self> {
-                use $crate::{
-                    array::Array,
-                    consts::U1,
-                    block_buffer::BlockBuffer,
-                    crypto_common::hazmat::SerializableState,
-                };
-
                 let serialized_core = self.core.serialize();
-                let pos = u8::try_from(self.buffer.get_pos()).unwrap();
-                let serialized_pos: Array<u8, U1> = Array([pos]);
-                let serialized_data = self.buffer.clone().pad_with_zeros();
-
-                serialized_core
-                    .concat(serialized_pos)
-                    .concat(serialized_data)
+                let serialized_buf = self.buffer.serialize();
+                serialized_core.concat(serialized_buf)
             }
 
             #[inline]
             fn deserialize(
                 serialized_state: &$crate::crypto_common::hazmat::SerializedState<Self>,
             ) -> Result<Self, $crate::crypto_common::hazmat::DeserializeStateError> {
-                use $crate::{
-                    block_buffer::BlockBuffer,
-                    consts::U1,
-                    crypto_common::hazmat::{SerializableState, DeserializeStateError},
-                };
+                use $crate::crypto_common::hazmat::{SerializableState, DeserializeStateError};
 
-                let (serialized_core, remaining_buffer) = serialized_state
+                let (serialized_core, serialized_buf) = serialized_state
                     .split_ref::<<$core_ty as SerializableState>::SerializedStateSize>();
-                let (serialized_pos, serialized_data) = remaining_buffer.split_ref::<U1>();
 
-                Ok(Self {
-                    core: <$core_ty as SerializableState>::deserialize(serialized_core)?,
-                    buffer: BlockBuffer::try_new(&serialized_data[..serialized_pos[0].into()])
-                        .map_err(|_| DeserializeStateError)?,
-                })
+                let core = SerializableState::deserialize(serialized_core)?;
+                let buffer = $crate::block_buffer::BlockBuffer::deserialize(serialized_buf)
+                    .map_err(|_| DeserializeStateError)?;
+
+                Ok(Self { core, buffer })
             }
         }
 
diff --git a/digest/src/buffer_macros/variable_ct.rs b/digest/src/buffer_macros/variable_ct.rs
index a767a1ca0..b02b69a57 100644
--- a/digest/src/buffer_macros/variable_ct.rs
+++ b/digest/src/buffer_macros/variable_ct.rs
@@ -176,54 +176,32 @@ macro_rules! buffer_ct_variable {
         where
             $out_size: $crate::array::ArraySize + $crate::typenum::IsLessOrEqual<$max_size, Output = $crate::typenum::True>,
         {
-            type SerializedStateSize = $crate::typenum::Add1<$crate::typenum::Sum<
-                <
-                    $crate::block_api::CtOutWrapper<$core_ty, $out_size>
-                    as $crate::crypto_common::hazmat::SerializableState
-                >::SerializedStateSize,
-                <$core_ty as $crate::block_api::BlockSizeUser>::BlockSize,
-            >>;
+            type SerializedStateSize = $crate::typenum::Sum<
+                <$core_ty as $crate::crypto_common::hazmat::SerializableState>::SerializedStateSize,
+                $crate::block_buffer::SerializedBufferSize<
+                    <$core_ty as $crate::block_api::BlockSizeUser>::BlockSize,
+                    <$core_ty as $crate::block_api::BufferKindUser>::BufferKind,
+                >
+            >;
 
             #[inline]
             fn serialize(&self) -> $crate::crypto_common::hazmat::SerializedState<Self> {
-                use $crate::{
-                    array::Array,
-                    consts::U1,
-                    block_buffer::BlockBuffer,
-                    crypto_common::hazmat::SerializableState,
-                };
-
                 let serialized_core = self.core.serialize();
-                let pos = u8::try_from(self.buffer.get_pos()).unwrap();
-                let serialized_pos: Array<u8, U1> = Array([pos]);
-                let serialized_data = self.buffer.clone().pad_with_zeros();
-
-                serialized_core
-                    .concat(serialized_pos)
-                    .concat(serialized_data)
+                let serialized_buf = self.buffer.serialize();
+                serialized_core.concat(serialized_buf)
             }
 
             #[inline]
             fn deserialize(
                 serialized_state: &$crate::crypto_common::hazmat::SerializedState<Self>,
             ) -> Result<Self, $crate::crypto_common::hazmat::DeserializeStateError> {
-                use $crate::{
-                    block_buffer::BlockBuffer,
-                    consts::U1,
-                    block_api::CtOutWrapper,
-                    crypto_common::hazmat::{SerializableState, DeserializeStateError},
-                };
-
-                let (serialized_core, remaining_buffer) = serialized_state
-                    .split_ref::<<
-                        CtOutWrapper<$core_ty, $out_size>
-                        as SerializableState
-                    >::SerializedStateSize>();
-                let (serialized_pos, serialized_data) = remaining_buffer.split_ref::<U1>();
+                use $crate::crypto_common::hazmat::{SerializableState, DeserializeStateError};
+
+                let (serialized_core, serialized_buf) = serialized_state
+                    .split_ref::<<$core_ty as SerializableState>::SerializedStateSize>();
 
                 let core = SerializableState::deserialize(serialized_core)?;
-                let pos = usize::from(serialized_pos[0]);
-                let buffer = BlockBuffer::try_new(&serialized_data[..pos])
+                let buffer = $crate::block_buffer::BlockBuffer::deserialize(serialized_buf)
                     .map_err(|_| DeserializeStateError)?;
 
                 Ok(Self { core, buffer })
diff --git a/digest/src/buffer_macros/xof.rs b/digest/src/buffer_macros/xof.rs
index 8687c18b4..c8cbe72c7 100644
--- a/digest/src/buffer_macros/xof.rs
+++ b/digest/src/buffer_macros/xof.rs
@@ -284,49 +284,33 @@ macro_rules! buffer_xof {
         impl $crate::crypto_common::hazmat::SerializableState for $name {
             type SerializedStateSize = $crate::typenum::Sum<
                 <$core_ty as $crate::crypto_common::hazmat::SerializableState>::SerializedStateSize,
-                $crate::typenum::Add1<
-                    <$core_ty as $crate::block_api::BlockSizeUser>::BlockSize
+                $crate::block_buffer::SerializedBufferSize<
+                    <$core_ty as $crate::block_api::BlockSizeUser>::BlockSize,
+                    <$core_ty as $crate::block_api::BufferKindUser>::BufferKind,
                 >
             >;
 
             #[inline]
             fn serialize(&self) -> $crate::crypto_common::hazmat::SerializedState<Self> {
-                use $crate::{
-                    array::Array,
-                    consts::U1,
-                    block_buffer::BlockBuffer,
-                    crypto_common::hazmat::SerializableState,
-                };
-
                 let serialized_core = self.core.serialize();
-                let pos = u8::try_from(self.buffer.get_pos()).unwrap();
-                let serialized_pos: Array<u8, U1> = Array([pos]);
-                let serialized_data = self.buffer.clone().pad_with_zeros();
-
-                serialized_core
-                    .concat(serialized_pos)
-                    .concat(serialized_data)
+                let serialized_buf = self.buffer.serialize();
+                serialized_core.concat(serialized_buf)
             }
 
             #[inline]
             fn deserialize(
                 serialized_state: &$crate::crypto_common::hazmat::SerializedState<Self>,
             ) -> Result<Self, $crate::crypto_common::hazmat::DeserializeStateError> {
-                use $crate::{
-                    block_buffer::BlockBuffer,
-                    consts::U1,
-                    crypto_common::hazmat::{SerializableState, DeserializeStateError},
-                };
+                use $crate::crypto_common::hazmat::{SerializableState, DeserializeStateError};
 
-                let (serialized_core, remaining_buffer) = serialized_state
+                let (serialized_core, serialized_buf) = serialized_state
                     .split_ref::<<$core_ty as SerializableState>::SerializedStateSize>();
-                let (serialized_pos, serialized_data) = remaining_buffer.split_ref::<U1>();
 
-                Ok(Self {
-                    core: <$core_ty as SerializableState>::deserialize(serialized_core)?,
-                    buffer: BlockBuffer::try_new(&serialized_data[..serialized_pos[0].into()])
-                        .map_err(|_| DeserializeStateError)?,
-                })
+                let core = SerializableState::deserialize(serialized_core)?;
+                let buffer = $crate::block_buffer::BlockBuffer::deserialize(serialized_buf)
+                    .map_err(|_| DeserializeStateError)?;
+
+                Ok(Self { core, buffer })
             }
         }
 
diff --git a/digest/src/dev.rs b/digest/src/dev.rs
index e7e4d0a23..abc174f96 100644
--- a/digest/src/dev.rs
+++ b/digest/src/dev.rs
@@ -54,7 +54,7 @@ macro_rules! new_test {
 /// Define hash function serialization test
 #[macro_export]
 macro_rules! hash_serialization_test {
-    ($name:ident, $hasher:ty, $expected_serialized_state:expr) => {
+    ($name:ident, $hasher:ty $(,)?) => {
         #[test]
         fn $name() {
             use digest::{
@@ -68,7 +68,8 @@ macro_rules! hash_serialization_test {
             h.update(&[0x13; <$hasher as BlockSizeUser>::BlockSize::USIZE + 1]);
 
             let serialized_state = h.serialize();
-            assert_eq!(serialized_state.as_slice(), $expected_serialized_state);
+            let expected = include_bytes!(concat!("data/", stringify!($name), ".bin"));
+            assert_eq!(serialized_state.as_slice(), expected);
 
             let mut h = <$hasher>::deserialize(&serialized_state).unwrap();
 
diff --git a/digest/tests/data/fixed_hash_serialization.bin b/digest/tests/data/fixed_hash_serialization.bin
new file mode 100644
index 000000000..2a034968a
Binary files /dev/null and b/digest/tests/data/fixed_hash_serialization.bin differ
diff --git a/digest/tests/dummy_fixed.rs b/digest/tests/dummy_fixed.rs
index cce734f59..e66b430a0 100644
--- a/digest/tests/dummy_fixed.rs
+++ b/digest/tests/dummy_fixed.rs
@@ -111,6 +111,9 @@ digest::buffer_fixed!(
     impl: FixedHashTraits;
 );
 
+#[cfg(feature = "dev")]
+digest::hash_serialization_test!(fixed_hash_serialization, FixedHashWithSer,);
+
 #[cfg(feature = "zeroize")]
 /// check for `ZeroizeOnDrop` implementations
 const _: () = {