diff --git a/relapse.cabal b/relapse.cabal
--- a/relapse.cabal
+++ b/relapse.cabal
@@ -1,5 +1,5 @@
 name:                relapse
-version:             0.1.0.1
+version:             0.1.1.0
 synopsis:            Sensible RLP encoding
 description:         An implementation of RLP as specified in the Ethereum Wiki, using Attoparsec
 homepage:            https://github.com/iostat/relapse#readme
diff --git a/src/Data/RLP.hs b/src/Data/RLP.hs
--- a/src/Data/RLP.hs
+++ b/src/Data/RLP.hs
@@ -7,12 +7,15 @@
     , unpackRLP
     , unpackRLPFully
     , packRLP
+    , rlpSerialize
+    , rlpDeserialize
     , module Data.RLP.Types
     ) where
 
 import           Control.Applicative        ((<|>))
 import           Data.Attoparsec.ByteString
 import           Data.Attoparsec.Combinator
+import           Control.Monad ((<=<))
 import           Data.Bits                  (Bits, FiniteBits, finiteBitSize,
                                              shiftL, shiftR, (.|.))
 import qualified Data.ByteString            as S
@@ -111,3 +114,9 @@
                     pLen     = S.pack (packFiniteBE len)
                     pLenLen  = fromIntegral (S.length pLen)
                     prefixed = base + pLenLen
+
+rlpSerialize :: RLPEncodable a => a -> S.ByteString
+rlpSerialize = packRLP . rlpEncode
+
+rlpDeserialize :: RLPEncodable a => S.ByteString -> Either String a
+rlpDeserialize = rlpDecode <=< unpackRLP
diff --git a/src/Data/RLP/Types.hs b/src/Data/RLP/Types.hs
--- a/src/Data/RLP/Types.hs
+++ b/src/Data/RLP/Types.hs
@@ -15,6 +15,9 @@
 
 data RLPObject = String S.ByteString | Array [RLPObject] deriving (Eq, Ord, Read, Show)
 
+rlp0 :: RLPObject
+rlp0 = String (S.singleton 0x80)
+
 class RLPEncodable a where
     rlpEncode :: a -> RLPObject
     rlpDecode :: RLPObject -> Either String a
@@ -68,7 +71,7 @@
         String s -> Right s
         x        -> rlpDecodeFail "String" x
 
-instance RLPEncodable String where
+instance {-# OVERLAPPING #-} RLPEncodable String where
     rlpEncode = String . S8.pack
     rlpDecode = \case
         String s -> Right (S8.unpack s)
@@ -90,11 +93,111 @@
     rlpEncode = rlpEncodeFinite
     rlpDecode = rlpDecodeIntegralBE
 
-instance (RLPEncodable a) => RLPEncodable [a] where
+instance {-# OVERLAPPABLE #-} (RLPEncodable a) => RLPEncodable [a] where
     rlpEncode = Array . toList . fmap rlpEncode
     rlpDecode = \case
         Array xs -> sequence $ rlpDecode <$> xs
         x        -> rlpDecodeFail "Array" x
+
+instance RLPEncodable () where
+    rlpEncode _ = rlp0
+    rlpDecode x = if x == rlp0 then return () else rlpDecodeFail "()" x
+
+instance (RLPEncodable a, RLPEncodable b) => RLPEncodable (a,b) where
+    rlpEncode (a,b) = Array [rlpEncode a,rlpEncode b]
+    rlpDecode = \case
+      Array [a,b] -> (,) <$> rlpDecode a <*> rlpDecode b
+      x           -> rlpDecodeFail "Pair" x
+
+instance
+  ( RLPEncodable a
+  , RLPEncodable b
+  , RLPEncodable c
+  ) => RLPEncodable (a,b,c) where
+  rlpEncode (a,b,c) = Array
+    [ rlpEncode a
+    , rlpEncode b
+    , rlpEncode c
+    ]
+  rlpDecode = \case
+    Array [a,b,c] -> (,,)
+      <$> rlpDecode a
+      <*> rlpDecode b
+      <*> rlpDecode c
+    x           -> rlpDecodeFail "Triple" x
+
+instance
+  ( RLPEncodable a
+  , RLPEncodable b
+  , RLPEncodable c
+  , RLPEncodable d
+  ) => RLPEncodable (a,b,c,d) where
+  rlpEncode (a,b,c,d) = Array
+    [ rlpEncode a
+    , rlpEncode b
+    , rlpEncode c
+    , rlpEncode d
+    ]
+  rlpDecode = \case
+    Array [a,b,c,d] -> (,,,)
+      <$> rlpDecode a
+      <*> rlpDecode b
+      <*> rlpDecode c
+      <*> rlpDecode d
+    x           -> rlpDecodeFail "Quadruple" x
+
+instance
+  ( RLPEncodable a
+  , RLPEncodable b
+  , RLPEncodable c
+  , RLPEncodable d
+  , RLPEncodable e
+  ) => RLPEncodable (a,b,c,d,e) where
+  rlpEncode (a,b,c,d,e) = Array
+    [ rlpEncode a
+    , rlpEncode b
+    , rlpEncode c
+    , rlpEncode d
+    , rlpEncode e
+    ]
+  rlpDecode = \case
+    Array [a,b,c,d,e] -> (,,,,)
+      <$> rlpDecode a
+      <*> rlpDecode b
+      <*> rlpDecode c
+      <*> rlpDecode d
+      <*> rlpDecode e
+    x           -> rlpDecodeFail "Quintuple" x
+
+instance
+  ( RLPEncodable a
+  , RLPEncodable b
+  , RLPEncodable c
+  , RLPEncodable d
+  , RLPEncodable e
+  , RLPEncodable f
+  ) => RLPEncodable (a,b,c,d,e,f) where
+  rlpEncode (a,b,c,d,e,f) = Array
+    [ rlpEncode a
+    , rlpEncode b
+    , rlpEncode c
+    , rlpEncode d
+    , rlpEncode e
+    , rlpEncode f
+    ]
+  rlpDecode = \case
+    Array [a,b,c,d,e,f] -> (,,,,,)
+      <$> rlpDecode a
+      <*> rlpDecode b
+      <*> rlpDecode c
+      <*> rlpDecode d
+      <*> rlpDecode e
+      <*> rlpDecode f
+    x           -> rlpDecodeFail "Sextuple" x
+
+instance RLPEncodable a => RLPEncodable (Maybe a) where
+    rlpEncode = maybe rlp0 rlpEncode
+    rlpDecode x = if x == rlp0 then return Nothing else Just <$> rlpDecode x
 
 instance RLPEncodable RLPObject where -- ayy lmao
     rlpEncode = id