diff --git a/src/boc/mod.rs b/src/boc/mod.rs
index 446e4223..014bc3a6 100644
--- a/src/boc/mod.rs
+++ b/src/boc/mod.rs
@@ -2,11 +2,17 @@
 
 use crate::cell::{Cell, CellBuilder, CellContext, CellFamily, DynCell, HashBytes, Load, Store};
 
+#[cfg(feature = "serde")]
+pub use self::serde::SerdeBoc;
+
 /// BOC decoder implementation.
 pub mod de;
 /// BOC encoder implementation.
 pub mod ser;
 
+#[cfg(feature = "serde")]
+mod serde;
+
 #[cfg(test)]
 mod tests;
 
@@ -47,41 +53,6 @@ impl BocTag {
     }
 }
 
-/// A serde helper to use [`Boc`] inside [`Option`].
-#[cfg(feature = "serde")]
-pub struct OptionBoc;
-
-#[cfg(feature = "serde")]
-impl OptionBoc {
-    /// Serializes an optional cell into an encoded BOC
-    /// (as base64 for human readable serializers).
-    pub fn serialize<S, T>(cell: &Option<T>, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-        T: AsRef<DynCell>,
-    {
-        match cell {
-            Some(cell) => serializer.serialize_some(cell.as_ref()),
-            None => serializer.serialize_none(),
-        }
-    }
-
-    /// Deserializes an optional cell from an encoded BOC
-    /// (from base64 for human readable deserializers).
-    pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<Cell>, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        use serde::Deserialize;
-
-        #[derive(Deserialize)]
-        #[repr(transparent)]
-        struct Wrapper(#[serde(with = "Boc")] Cell);
-
-        Ok(ok!(Option::<Wrapper>::deserialize(deserializer)).map(|Wrapper(cell)| cell))
-    }
-}
-
 /// BOC (Bag Of Cells) helper.
 pub struct Boc;
 
@@ -306,40 +277,26 @@ impl Boc {
 
     /// Serializes cell into an encoded BOC (as base64 for human readable serializers).
     #[cfg(feature = "serde")]
-    pub fn serialize<S, T>(cell: &T, serializer: S) -> Result<S::Ok, S::Error>
+    pub fn serialize<T, S>(value: T, serializer: S) -> Result<S::Ok, S::Error>
     where
-        S: serde::Serializer,
-        T: AsRef<DynCell> + ?Sized,
+        SerdeBoc<T>: ::serde::Serialize,
+        S: ::serde::Serializer,
     {
-        use serde::Serialize;
+        use ::serde::Serialize;
 
-        cell.as_ref().serialize(serializer)
+        SerdeBoc::from(value).serialize(serializer)
     }
 
     /// Deserializes cell from an encoded BOC (from base64 for human readable deserializers).
     #[cfg(feature = "serde")]
-    pub fn deserialize<'de, D>(deserializer: D) -> Result<Cell, D::Error>
+    pub fn deserialize<'de, T, D>(deserializer: D) -> Result<T, D::Error>
     where
-        D: serde::Deserializer<'de>,
+        SerdeBoc<T>: ::serde::Deserialize<'de>,
+        D: ::serde::Deserializer<'de>,
     {
-        use serde::de::Error;
+        use ::serde::Deserialize;
 
-        let is_human_readable = deserializer.is_human_readable();
-        let mut boc = ok!(borrow_cow_bytes(deserializer));
-
-        if is_human_readable {
-            match crate::util::decode_base64(boc) {
-                Ok(bytes) => {
-                    boc = std::borrow::Cow::Owned(bytes);
-                }
-                Err(_) => return Err(Error::custom("invalid base64 string")),
-            }
-        }
-
-        match Boc::decode(boc) {
-            Ok(cell) => Ok(cell),
-            Err(e) => Err(Error::custom(e)),
-        }
+        SerdeBoc::<T>::deserialize(deserializer).map(SerdeBoc::into_inner)
     }
 }
 
@@ -534,10 +491,10 @@ impl BocRepr {
     #[cfg(feature = "serde")]
     pub fn serialize<S, T>(data: &T, serializer: S) -> Result<S::Ok, S::Error>
     where
-        S: serde::Serializer,
+        S: ::serde::Serializer,
         T: Store,
     {
-        use serde::ser::{Error, Serialize};
+        use ::serde::ser::{Error, Serialize};
 
         let context = &mut Cell::empty_context();
 
@@ -559,12 +516,12 @@ impl BocRepr {
     #[cfg(feature = "serde")]
     pub fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error>
     where
-        D: serde::Deserializer<'de>,
+        D: ::serde::Deserializer<'de>,
         for<'a> T: Load<'a>,
     {
-        use serde::de::Error;
+        use ::serde::de::Error;
 
-        let cell = ok!(Boc::deserialize(deserializer));
+        let cell = ok!(Boc::deserialize::<Cell, _>(deserializer));
         match cell.as_ref().parse::<T>() {
             Ok(data) => Ok(data),
             Err(_) => Err(Error::custom("failed to decode object from cells")),
@@ -582,67 +539,3 @@ pub enum BocReprError {
     #[error("failed to decode object from cells")]
     InvalidData(#[source] crate::error::Error),
 }
-
-#[cfg(feature = "serde")]
-fn borrow_cow_bytes<'de: 'a, 'a, D>(deserializer: D) -> Result<std::borrow::Cow<'a, [u8]>, D::Error>
-where
-    D: serde::Deserializer<'de>,
-{
-    use std::borrow::Cow;
-
-    use serde::de::{Error, Visitor};
-
-    struct CowBytesVisitor;
-
-    impl<'a> Visitor<'a> for CowBytesVisitor {
-        type Value = Cow<'a, [u8]>;
-
-        fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
-            formatter.write_str("a byte array")
-        }
-
-        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            Ok(Cow::Owned(v.as_bytes().to_vec()))
-        }
-
-        fn visit_borrowed_str<E>(self, v: &'a str) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            Ok(Cow::Borrowed(v.as_bytes()))
-        }
-
-        fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            Ok(Cow::Owned(v.into_bytes()))
-        }
-
-        fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            Ok(Cow::Owned(v.to_vec()))
-        }
-
-        fn visit_borrowed_bytes<E>(self, v: &'a [u8]) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            Ok(Cow::Borrowed(v))
-        }
-
-        fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            Ok(Cow::Owned(v))
-        }
-    }
-
-    deserializer.deserialize_bytes(CowBytesVisitor)
-}
diff --git a/src/boc/serde.rs b/src/boc/serde.rs
new file mode 100644
index 00000000..9fffb19e
--- /dev/null
+++ b/src/boc/serde.rs
@@ -0,0 +1,397 @@
+use std::borrow::Cow;
+use std::collections::{BTreeMap, HashMap};
+use std::hash::{BuildHasher, Hash};
+use std::marker::PhantomData;
+use std::rc::Rc;
+use std::sync::Arc;
+
+use serde::de::{MapAccess, Visitor};
+use serde::ser::SerializeTuple;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+use crate::cell::{Cell, DynCell};
+
+// === SerdeBoc ===
+
+/// A wrapper type which implements `Serialize` and `Deserialize` for
+/// types involving `Cell`.
+#[repr(transparent)]
+pub struct SerdeBoc<T: ?Sized>(T);
+
+impl<T: ?Sized> SerdeBoc<T> {
+    /// Creates a wrapper around a reference to the value.
+    #[inline(always)]
+    pub const fn wrap(value: &T) -> &Self {
+        // SAFETY: SerdeBoc is #[repr(transparent)]
+        unsafe { &*(value as *const T as *const Self) }
+    }
+}
+
+impl<T> SerdeBoc<T> {
+    #[inline(always)]
+    const fn wrap_slice(value: &[T]) -> &[Self] {
+        // SAFETY: SerdeBoc is #[repr(transparent)]
+        unsafe { std::slice::from_raw_parts(value.as_ptr() as *const Self, value.len()) }
+    }
+
+    /// Consumes self, returning the inner value.
+    #[inline(always)]
+    pub fn into_inner(self) -> T {
+        self.0
+    }
+}
+
+impl<T> From<T> for SerdeBoc<T> {
+    #[inline]
+    fn from(val: T) -> SerdeBoc<T> {
+        Self(val)
+    }
+}
+
+impl<T: SerializeAsBoc> Serialize for SerdeBoc<T> {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        self.0.serialize_as_boc(serializer)
+    }
+}
+
+impl<'de, T: DeserializeAsBoc<'de>> Deserialize<'de> for SerdeBoc<T> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        T::deserialize_as_boc(deserializer).map(Self)
+    }
+}
+
+// === Serializer stuff ===
+
+trait SerializeAsBoc {
+    fn serialize_as_boc<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>;
+}
+
+impl SerializeAsBoc for Cell {
+    #[inline]
+    fn serialize_as_boc<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        self.as_ref().serialize(serializer)
+    }
+}
+
+impl SerializeAsBoc for DynCell {
+    #[inline]
+    fn serialize_as_boc<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        self.serialize(serializer)
+    }
+}
+
+impl<T: SerializeAsBoc> SerializeAsBoc for &'_ T {
+    #[inline]
+    fn serialize_as_boc<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        T::serialize_as_boc(self, serializer)
+    }
+}
+
+impl<T: SerializeAsBoc> SerializeAsBoc for Option<T> {
+    #[inline]
+    fn serialize_as_boc<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        self.as_ref().map(SerdeBoc::<T>::wrap).serialize(serializer)
+    }
+}
+
+impl<T: SerializeAsBoc> SerializeAsBoc for Box<T> {
+    #[inline]
+    fn serialize_as_boc<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        T::serialize_as_boc(self.as_ref(), serializer)
+    }
+}
+
+impl<T: SerializeAsBoc> SerializeAsBoc for Rc<T> {
+    #[inline]
+    fn serialize_as_boc<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        T::serialize_as_boc(self.as_ref(), serializer)
+    }
+}
+
+impl<T: SerializeAsBoc> SerializeAsBoc for Arc<T> {
+    #[inline]
+    fn serialize_as_boc<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        T::serialize_as_boc(self.as_ref(), serializer)
+    }
+}
+
+impl<T: SerializeAsBoc> SerializeAsBoc for [T] {
+    #[inline]
+    fn serialize_as_boc<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        SerdeBoc::wrap_slice(self).serialize(serializer)
+    }
+}
+
+impl<T: SerializeAsBoc> SerializeAsBoc for Vec<T> {
+    #[inline]
+    fn serialize_as_boc<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        self.as_slice().serialize_as_boc(serializer)
+    }
+}
+
+impl<T> SerializeAsBoc for [T; 0] {
+    #[inline]
+    fn serialize_as_boc<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        ok!(serializer.serialize_tuple(0)).end()
+    }
+}
+
+macro_rules! serialize_as_boc_array_impls {
+    ($($len:tt)+) => {
+        $(
+            #[allow(clippy::zero_prefixed_literal)]
+            impl<T: SerializeAsBoc> SerializeAsBoc for [T; $len] {
+                #[inline]
+                fn serialize_as_boc<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+                where
+                    S: Serializer,
+                {
+                    let mut seq = ok!(serializer.serialize_tuple($len));
+                    for e in self {
+                        ok!(seq.serialize_element(SerdeBoc::<T>::wrap(e)));
+                    }
+                    seq.end()
+                }
+            }
+        )+
+    }
+}
+
+serialize_as_boc_array_impls! {
+    01 02 03 04 05 06 07 08 09 10
+    11 12 13 14 15 16 17 18 19 20
+    21 22 23 24 25 26 27 28 29 30
+    31 32
+}
+
+macro_rules! serialize_as_boc_map_impl {
+    ($ty:ident<K$(: $kbound1:ident $(+ $kbound2:ident)*)*, V$(, $typaram:ident: $bound:ident)*>) => {
+        impl<K, V$(, $typaram)*> SerializeAsBoc for $ty<K, V$(, $typaram)*>
+        where
+            K: Serialize $(+ $kbound1 $(+ $kbound2)*)*,
+            V: SerializeAsBoc,
+            $($typaram: $bound,)*
+        {
+            #[inline]
+            fn serialize_as_boc<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+            where
+                S: Serializer,
+            {
+                serializer.collect_map(self.iter().map(|(k, v)| (k, SerdeBoc::wrap(v))))
+            }
+        }
+    }
+}
+
+serialize_as_boc_map_impl! { BTreeMap<K: Ord, V> }
+serialize_as_boc_map_impl! { HashMap<K: Eq + Hash, V, H: BuildHasher> }
+
+// === Deserializer stuff ===
+
+trait DeserializeAsBoc<'de>: Sized {
+    fn deserialize_as_boc<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>;
+}
+
+impl<'de> DeserializeAsBoc<'de> for Cell {
+    fn deserialize_as_boc<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        use serde::de::Error;
+
+        let is_human_readable = deserializer.is_human_readable();
+        let mut boc = ok!(borrow_cow_bytes(deserializer));
+
+        if is_human_readable {
+            match crate::util::decode_base64(boc) {
+                Ok(bytes) => {
+                    boc = Cow::Owned(bytes);
+                }
+                Err(_) => return Err(Error::custom("invalid base64 string")),
+            }
+        }
+
+        match crate::boc::Boc::decode(boc) {
+            Ok(cell) => Ok(cell),
+            Err(e) => Err(Error::custom(e)),
+        }
+    }
+}
+
+impl<'de, T: DeserializeAsBoc<'de>> DeserializeAsBoc<'de> for Box<T> {
+    #[inline]
+    fn deserialize_as_boc<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        let value = ok!(Box::<SerdeBoc<T>>::deserialize(deserializer));
+        // SAFETY: `SerdeBoc<T>` has the same layout as `T`.
+        Ok(unsafe { Box::from_raw(Box::into_raw(value).cast::<T>()) })
+    }
+}
+
+impl<'de, T: DeserializeAsBoc<'de>> DeserializeAsBoc<'de> for Option<T> {
+    #[inline]
+    fn deserialize_as_boc<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        Ok(ok!(Option::<SerdeBoc<T>>::deserialize(deserializer)).map(SerdeBoc::into_inner))
+    }
+}
+
+impl<'de, T: DeserializeAsBoc<'de>> DeserializeAsBoc<'de> for Vec<T> {
+    #[inline]
+    fn deserialize_as_boc<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        Ok(ok!(Vec::<SerdeBoc<T>>::deserialize(deserializer))
+            .into_iter()
+            .map(SerdeBoc::into_inner)
+            .collect())
+    }
+}
+
+impl<'de, T: DeserializeAsBoc<'de>, const N: usize> DeserializeAsBoc<'de> for [T; N]
+where
+    [SerdeBoc<T>; N]: Deserialize<'de>,
+{
+    fn deserialize_as_boc<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        let value = ok!(<[SerdeBoc<T>; N]>::deserialize(deserializer));
+        Ok(value.map(SerdeBoc::into_inner))
+    }
+}
+
+macro_rules! deserialize_as_boc_map_impl {
+    (
+        $ty:ident <K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound1:ident $(+ $bound2:ident)*)*>,
+        $access:ident,
+        $with_capacity:expr,
+    ) => {
+        impl<'de, K, V $(, $typaram)*> DeserializeAsBoc<'de> for $ty<K, V $(, $typaram)*>
+        where
+            K: Deserialize<'de> $(+ $kbound1 $(+ $kbound2)*)*,
+            V: DeserializeAsBoc<'de>,
+            $($typaram: $bound1 $(+ $bound2)*),*
+        {
+            fn deserialize_as_boc<D>(deserializer: D) -> Result<Self, D::Error>
+            where
+                D: Deserializer<'de>,
+            {
+                struct MapVisitor<K, V $(, $typaram)*> {
+                    marker: PhantomData<$ty<K, V $(, $typaram)*>>,
+                }
+
+                impl<'de, K, V $(, $typaram)*> Visitor<'de> for MapVisitor<K, V $(, $typaram)*>
+                where
+                    K: Deserialize<'de> $(+ $kbound1 $(+ $kbound2)*)*,
+                    V: DeserializeAsBoc<'de>,
+                    $($typaram: $bound1 $(+ $bound2)*),*
+                {
+                    type Value = $ty<K, V $(, $typaram)*>;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                        formatter.write_str("a map")
+                    }
+
+                    #[inline]
+                    fn visit_map<A>(self, mut $access: A) -> Result<Self::Value, A::Error>
+                    where
+                        A: MapAccess<'de>,
+                    {
+                        let mut values = $with_capacity;
+
+                        while let Some((key, SerdeBoc(value))) = ok!($access.next_entry()) {
+                            values.insert(key, value);
+                        }
+
+                        Ok(values)
+                    }
+                }
+
+                let visitor = MapVisitor { marker: PhantomData };
+                deserializer.deserialize_map(visitor)
+            }
+        }
+    }
+}
+
+deserialize_as_boc_map_impl! {
+    BTreeMap<K: Ord, V>,
+    map,
+    BTreeMap::new(),
+}
+
+deserialize_as_boc_map_impl! {
+    HashMap<K: Eq + Hash, V, S: BuildHasher + Default>,
+    map,
+    HashMap::with_capacity_and_hasher(cautious_size_hint::<(K, V)>(map.size_hint()), S::default()),
+}
+
+fn cautious_size_hint<Element>(hint: Option<usize>) -> usize {
+    const MAX_PREALLOC_BYTES: usize = 1024 * 1024;
+
+    if std::mem::size_of::<Element>() == 0 {
+        0
+    } else {
+        std::cmp::min(
+            hint.unwrap_or(0),
+            MAX_PREALLOC_BYTES / std::mem::size_of::<Element>(),
+        )
+    }
+}
+
+// === Other stuff ===
+
+fn borrow_cow_bytes<'de: 'a, 'a, D>(deserializer: D) -> Result<std::borrow::Cow<'a, [u8]>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    use serde::de::Error;
+
+    struct CowBytesVisitor;
+
+    impl<'a> Visitor<'a> for CowBytesVisitor {
+        type Value = Cow<'a, [u8]>;
+
+        fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+            formatter.write_str("a byte array")
+        }
+
+        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+        where
+            E: Error,
+        {
+            Ok(Cow::Owned(v.as_bytes().to_vec()))
+        }
+
+        fn visit_borrowed_str<E>(self, v: &'a str) -> Result<Self::Value, E>
+        where
+            E: Error,
+        {
+            Ok(Cow::Borrowed(v.as_bytes()))
+        }
+
+        fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
+        where
+            E: Error,
+        {
+            Ok(Cow::Owned(v.into_bytes()))
+        }
+
+        fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+        where
+            E: Error,
+        {
+            Ok(Cow::Owned(v.to_vec()))
+        }
+
+        fn visit_borrowed_bytes<E>(self, v: &'a [u8]) -> Result<Self::Value, E>
+        where
+            E: Error,
+        {
+            Ok(Cow::Borrowed(v))
+        }
+
+        fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
+        where
+            E: Error,
+        {
+            Ok(Cow::Owned(v))
+        }
+    }
+
+    deserializer.deserialize_bytes(CowBytesVisitor)
+}
diff --git a/src/models/account/mod.rs b/src/models/account/mod.rs
index b0937bb3..e411e8b8 100644
--- a/src/models/account/mod.rs
+++ b/src/models/account/mod.rs
@@ -374,10 +374,10 @@ pub struct StateInit {
     /// Optional special contract flags.
     pub special: Option<SpecialFlags>,
     /// Optional contract code.
-    #[cfg_attr(feature = "serde", serde(with = "crate::boc::OptionBoc"))]
+    #[cfg_attr(feature = "serde", serde(with = "crate::boc::Boc"))]
     pub code: Option<Cell>,
     /// Optional contract data.
-    #[cfg_attr(feature = "serde", serde(with = "crate::boc::OptionBoc"))]
+    #[cfg_attr(feature = "serde", serde(with = "crate::boc::Boc"))]
     pub data: Option<Cell>,
     /// Libraries used in smart-contract.
     pub libraries: Dict<HashBytes, SimpleLib>,
diff --git a/src/models/transaction/mod.rs b/src/models/transaction/mod.rs
index b4c248e4..afb0f71a 100644
--- a/src/models/transaction/mod.rs
+++ b/src/models/transaction/mod.rs
@@ -99,7 +99,7 @@ mod serde_in_msg {
                 None => serializer.serialize_none(),
             }
         } else {
-            crate::boc::OptionBoc::serialize(in_msg, serializer)
+            crate::boc::Boc::serialize(in_msg, serializer)
         }
     }
 
@@ -119,7 +119,7 @@ mod serde_in_msg {
                 None => Ok(None),
             }
         } else {
-            crate::boc::OptionBoc::deserialize(deserializer)
+            crate::boc::Boc::deserialize(deserializer)
         }
     }
 }
diff --git a/src/prelude.rs b/src/prelude.rs
index f17f8f0c..d2d29cb5 100644
--- a/src/prelude.rs
+++ b/src/prelude.rs
@@ -9,6 +9,3 @@ pub use crate::cell::{
     UsageTree, UsageTreeMode,
 };
 pub use crate::dict::{AugDict, Dict, RawDict};
-
-#[cfg(feature = "serde")]
-pub use crate::boc::OptionBoc;