diff --git a/libsecp256k1.cabal b/libsecp256k1.cabal
--- a/libsecp256k1.cabal
+++ b/libsecp256k1.cabal
@@ -5,7 +5,7 @@
 -- see: https://github.com/sol/hpack
 
 name:           libsecp256k1
-version:        0.1.5
+version:        0.2.0
 synopsis:       Bindings for secp256k1
 description:    Sign and verify signatures using the secp256k1 library.
 category:       Crypto
diff --git a/src/Crypto/Secp256k1.hs b/src/Crypto/Secp256k1.hs
--- a/src/Crypto/Secp256k1.hs
+++ b/src/Crypto/Secp256k1.hs
@@ -2,7 +2,6 @@
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE GADTs #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE MultiWayIf #-}
 {-# LANGUAGE RankNTypes #-}
 {-# LANGUAGE RecordWildCards #-}
 {-# LANGUAGE ScopedTypeVariables #-}
@@ -35,7 +34,8 @@
     exportPubKeyXY,
     importPubKeyXO,
     exportPubKeyXO,
-    importSignature,
+    importSignatureCompact,
+    importSignatureDer,
     exportSignatureCompact,
     exportSignatureDer,
     importRecoverableSignature,
@@ -80,6 +80,7 @@
     ecdh,
 ) where
 
+import Control.Applicative (Alternative (..))
 import Control.DeepSeq (NFData (..))
 import Control.Monad (replicateM, unless, (<=<))
 import Control.Monad.Trans.Class (lift)
@@ -255,7 +256,7 @@
     kp == kp' = unsafePerformIO . evalContT $ do
         kpp <- ContT $ withForeignPtr (keyPairFPtr kp)
         kpp' <- ContT $ withForeignPtr (keyPairFPtr kp')
-        (EQ ==) <$> lift (memCompare (castPtr kpp) (castPtr kpp') 32)
+        (EQ ==) <$> lift (memCompare (castPtr kpp) (castPtr kpp') 96)
 instance NFData KeyPair where
     rnf KeyPair{..} = seq keyPairFPtr ()
 
@@ -269,7 +270,7 @@
 instance Read Signature where
     readsPrec i cs = case decodeBase16 $ B8.pack token of
         Left e -> []
-        Right a -> maybeToList $ (,rest) <$> importSignature a
+        Right a -> maybeToList $ (,rest) <$> (importSignatureCompact a <|> importSignatureDer a)
         where
             trimmed = dropWhile isSpace cs
             (token, rest) = span isAlphaNum trimmed
@@ -277,7 +278,7 @@
     sig == sig' = unsafePerformIO . evalContT $ do
         sigp <- ContT $ withForeignPtr (signatureFPtr sig)
         sigp' <- ContT $ withForeignPtr (signatureFPtr sig')
-        (EQ ==) <$> lift (memCompare (castPtr sigp) (castPtr sigp') 32)
+        (EQ ==) <$> lift (memCompare (castPtr sigp) (castPtr sigp') 64)
 instance NFData Signature where
     rnf Signature{..} = seq signatureFPtr ()
 
@@ -299,7 +300,7 @@
     rs == rs' = unsafePerformIO . evalContT $ do
         rsp <- ContT $ withForeignPtr (recoverableSignatureFPtr rs)
         rsp' <- ContT $ withForeignPtr (recoverableSignatureFPtr rs')
-        (EQ ==) <$> lift (memCompare (castPtr rsp) (castPtr rsp') 32)
+        (EQ ==) <$> lift (memCompare (castPtr rsp) (castPtr rsp') 65)
 instance NFData RecoverableSignature where
     rnf RecoverableSignature{..} = seq recoverableSignatureFPtr ()
 
@@ -414,24 +415,33 @@
     unsafePackByteString (outBuf, 32)
 
 
--- | Parses 'Signature' from DER (71 | 72 | 73 bytes) or Compact (64 bytes) representations.
-importSignature :: ByteString -> Maybe Signature
-importSignature bs = unsafePerformIO $
+-- | Parses 'Signature' from Compact (64 bytes) representation.
+importSignatureCompact :: ByteString -> Maybe Signature
+importSignatureCompact bs = unsafePerformIO $
     unsafeUseByteString bs $ \(inBuf, len) -> do
         outBuf <- mallocBytes 64
         ret <-
-            if
+            if len == 64
                 -- compact
-                | len == 64 -> Prim.ecdsaSignatureParseCompact ctx outBuf inBuf
-                -- der
-                | len >= 69 && len <= 73 -> Prim.ecdsaSignatureParseDer ctx outBuf inBuf len
+                then Prim.ecdsaSignatureParseCompact ctx outBuf inBuf
                 -- invalid
-                | otherwise -> pure 0
+                else pure 0
         if isSuccess ret
             then Just . Signature <$> newForeignPtr finalizerFree outBuf
             else free outBuf $> Nothing
 
 
+-- | Parses 'Signature' from DER representation.
+importSignatureDer :: ByteString -> Maybe Signature
+importSignatureDer bs = unsafePerformIO $
+    unsafeUseByteString bs $ \(inBuf, len) -> do
+        outBuf <- mallocBytes 64
+        ret <- Prim.ecdsaSignatureParseDer ctx outBuf inBuf len
+        if isSuccess ret
+            then Just . Signature <$> newForeignPtr finalizerFree outBuf
+            else pure Nothing
+
+
 -- | Serializes 'Signature' to Compact (64 byte) representation
 exportSignatureCompact :: Signature -> ByteString
 exportSignatureCompact (Signature fptr) = unsafePerformIO $ do
@@ -843,7 +853,3 @@
         tweakPtr <- ContT (withForeignPtr tweakFPtr)
         let parityInt = if parity then 1 else 0
         lift $ isSuccess <$> Prim.xonlyPubkeyTweakAddCheck ctx tweakedPtr parityInt origPtr tweakPtr
-
-
-foreign import ccall "wrapper"
-    mkNonceFunHardened :: Prim.NonceFunHardened a -> IO (FunPtr (Prim.NonceFunHardened a))
diff --git a/test/Crypto/Secp256k1Prop.hs b/test/Crypto/Secp256k1Prop.hs
--- a/test/Crypto/Secp256k1Prop.hs
+++ b/test/Crypto/Secp256k1Prop.hs
@@ -123,7 +123,8 @@
     let serialized = export sig
     annotateShow serialized
     annotateShow (BS.length serialized)
-    case importSignature serialized of
+    let parse = if exportDer then importSignatureDer else importSignatureCompact
+    case parse serialized of
         Nothing -> failure
         Just x -> x === sig
 
@@ -185,12 +186,12 @@
     msg <- forAll $ bytes (singleton 32)
     sig <- maybe failure pure $ ecdsaSign sk msg
     useDer <- forAll enumBounded
-    let export =
+    let (serialize, parse) =
             if useDer
-                then exportSignatureDer
-                else exportSignatureCompact
-    let serialized = export sig
-    let parsed = fromJust (importSignature serialized)
+                then (exportSignatureDer, importSignatureDer)
+                else (exportSignatureCompact, importSignatureCompact)
+    let serialized = serialize sig
+    let parsed = fromJust (parse serialized)
     assert $ ecdsaVerify msg (derivePubKey sk) parsed
 
 
diff --git a/test/Crypto/Secp256k1Spec.hs b/test/Crypto/Secp256k1Spec.hs
--- a/test/Crypto/Secp256k1Spec.hs
+++ b/test/Crypto/Secp256k1Spec.hs
@@ -3,6 +3,7 @@
 import Control.Monad.Par qualified as P
 import Crypto.Secp256k1
 import Crypto.Secp256k1.Internal
+import Data.ByteArray.Encoding (Base (Base16), convertFromBase)
 import Data.ByteString qualified as BS
 import Data.ByteString.Char8 qualified as B8
 import Data.Either (fromRight)
@@ -69,7 +70,7 @@
 
 serializeSigTest :: (BS.ByteString, SecKey) -> Bool
 serializeSigTest (fm, fk) =
-    (fg >>= importSignature . exportSignatureDer) == fg && isJust fg
+    (fg >>= importSignatureDer . exportSignatureDer) == fg && isJust fg
     where
         fg = ecdsaSign fk fm
 
@@ -82,7 +83,7 @@
 
 serializeCompactSigTest :: (BS.ByteString, SecKey) -> Bool
 serializeCompactSigTest (fm, fk) =
-    (fg >>= importSignature . exportSignatureCompact) == fg && isJust fg
+    (fg >>= importSignatureCompact . exportSignatureCompact) == fg && isJust fg
     where
         fg = ecdsaSign fk fm