diff --git a/secp256k1.cabal b/secp256k1.cabal
--- a/secp256k1.cabal
+++ b/secp256k1.cabal
@@ -1,5 +1,5 @@
 name:                secp256k1
-version:             0.1.4
+version:             0.1.5
 synopsis:            secp256k1 bindings for Haskell
 description:         Please see README.md
 homepage:            http://github.com/haskoin/secp256k1#readme
@@ -18,6 +18,7 @@
   exposed-modules:     Crypto.Secp256k1
                      , Crypto.Secp256k1.Internal
   build-depends:       base >= 4.8 && < 5
+                     , QuickCheck
                      , bytestring
                      , mtl
                      , entropy
diff --git a/src/Crypto/Secp256k1.hs b/src/Crypto/Secp256k1.hs
--- a/src/Crypto/Secp256k1.hs
+++ b/src/Crypto/Secp256k1.hs
@@ -39,6 +39,7 @@
 import           Data.String.Conversions
 import           Foreign
 import           System.IO.Unsafe
+import           Test.QuickCheck
 import           Text.Read
 
 -- | Internal public key data type.
@@ -339,3 +340,23 @@
     pointers ps [] f = f ps
     pointers ps (PubKey fp : pubs') f =
         withForeignPtr fp $ \p -> pointers (p:ps) pubs' f
+
+instance Arbitrary Msg where
+    arbitrary = gen_msg
+      where
+        valid_bs = bs_gen `suchThat` isJust
+        bs_gen = (msg . BS.pack) <$> sequence (replicate 32 arbitrary)
+        gen_msg = fromJust <$> valid_bs
+
+instance Arbitrary SecKey where
+    arbitrary = gen_key
+      where
+        valid_bs = bs_gen `suchThat` isJust
+        bs_gen = (secKey . BS.pack) <$> sequence (replicate 32 arbitrary)
+        gen_key = fromJust <$> valid_bs
+
+instance Arbitrary PubKey where
+    arbitrary = do
+        key <- arbitrary
+        return $ pubKey key
+
diff --git a/test/Crypto/Secp256k1/Tests.hs b/test/Crypto/Secp256k1/Tests.hs
--- a/test/Crypto/Secp256k1/Tests.hs
+++ b/test/Crypto/Secp256k1/Tests.hs
@@ -1,15 +1,12 @@
 module Crypto.Secp256k1.Tests (tests) where
 
 import           Crypto.Secp256k1
-import qualified Data.ByteString                      as BS
 import qualified Data.ByteString.Base16               as B16
 import qualified Data.ByteString.Char8                as B8
-import           Data.Maybe
 import           Test.Framework                       (Test, testGroup)
 import           Test.Framework.Providers.HUnit       (testCase)
 import           Test.Framework.Providers.QuickCheck2 (testProperty)
 import           Test.HUnit                           (Assertion, assertEqual)
-import           Test.QuickCheck
 
 tests :: [Test]
 tests =
@@ -31,56 +28,33 @@
         ]
     ]
 
-newtype GenMsg = GenMsg Msg deriving (Show, Eq)
-newtype GenSecKey = GenSecKey SecKey deriving (Show, Eq)
-newtype GenPubKey = GenPubKey PubKey deriving (Show, Eq)
-
-instance Arbitrary GenMsg where
-    arbitrary = gen_msg
-      where
-        valid_bs = bs_gen `suchThat` isJust
-        bs_gen = (msg . BS.pack) <$> sequence (replicate 32 arbitrary)
-        gen_msg = (GenMsg . fromJust) <$> valid_bs
-
-instance Arbitrary GenSecKey where
-    arbitrary = gen_key
-      where
-        valid_bs = bs_gen `suchThat` isJust
-        bs_gen = (secKey . BS.pack) <$> sequence (replicate 32 arbitrary)
-        gen_key = (GenSecKey . fromJust) <$> valid_bs
-
-instance Arbitrary GenPubKey where
-    arbitrary = do
-        GenSecKey key <- arbitrary
-        return $ GenPubKey $ pubKey key
-
-signMsgTest :: (GenMsg, GenSecKey) -> Bool
-signMsgTest (GenMsg fm, GenSecKey fk) = verifySig fp fg fm where
+signMsgTest :: (Msg, SecKey) -> Bool
+signMsgTest (fm, fk) = verifySig fp fg fm where
     fp = pubKey fk
     fg = signMsg fk fm
 
-badSignatureTest :: (GenMsg, GenSecKey, GenPubKey) -> Bool
-badSignatureTest (GenMsg fm, GenSecKey fk, GenPubKey fp) =
+badSignatureTest :: (Msg, SecKey, PubKey) -> Bool
+badSignatureTest (fm, fk, fp) =
     not $ verifySig fp fg fm
   where
     fg = signMsg fk fm
 
-serializePubKeyTest :: (GenPubKey, Bool) -> Bool
-serializePubKeyTest (GenPubKey fp, b) =
+serializePubKeyTest :: (PubKey, Bool) -> Bool
+serializePubKeyTest (fp, b) =
     case importPubKey $ exportPubKey b fp of
         Just fp' -> fp == fp'
         Nothing -> False
 
-serializeSigTest :: (GenMsg, GenSecKey) -> Bool
-serializeSigTest (GenMsg fm, GenSecKey fk) =
+serializeSigTest :: (Msg, SecKey) -> Bool
+serializeSigTest (fm, fk) =
     case importSig $ exportSig fg of
         Just fg' -> fg == fg'
         Nothing -> False
   where
     fg = signMsg fk fm
 
-serializeSecKeyTest :: (GenSecKey, Bool) -> Bool
-serializeSecKeyTest (GenSecKey fk, b) =
+serializeSecKeyTest :: (SecKey, Bool) -> Bool
+serializeSecKeyTest (fk, b) =
     case importSecKey $ exportSecKey b fk of
         Just fk' -> fk == fk'
         Nothing -> False