Merge branch 'tidy' into dev

75 files changed, 3127 insertions, 3690 deletions

diff --git a/.travis.yml b/.travis.yml
index 72fd69a4..3130bc52 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -13,7 +13,8 @@ install:
   - ./dev/update-dependencies.sh
 
 script:
-  - cabal configure --enable-tests --enable-benchmark && cabal build && ./dist/build/spec/spec
+  - cabal configure && cabal build
+  - cabal configure -ftesting --enable-tests --enable-benchmark && cabal build && ./dist/build/spec/spec
 
 notifications:
   email:
diff --git a/bittorrent.cabal b/bittorrent.cabal
index af6caefa..550a727d 100644
--- a/bittorrent.cabal
+++ b/bittorrent.cabal
@@ -34,6 +34,10 @@ source-repository this
   branch:              master
   tag:                 v0.0.0.3
 
+flag testing
+  description:         Whether to build tests.
+  default:             False
+
 flag examples
   description:         Whether to build examples.
   default:             False
@@ -45,22 +49,11 @@ library
                      , RecordWildCards
   hs-source-dirs:      src
   exposed-modules:     Data.Torrent
-                       Data.Torrent.Bitfield
-                       Data.Torrent.InfoHash
-                       Data.Torrent.Layout
-                       Data.Torrent.Magnet
-                       Data.Torrent.Piece
-                       Data.Torrent.Progress
-                       Data.Torrent.Tree
                        Network.BitTorrent
+                       Network.BitTorrent.Address
                        Network.BitTorrent.Client
                        Network.BitTorrent.Client.Types
                        Network.BitTorrent.Client.Handle
-                       Network.BitTorrent.Core
-                       Network.BitTorrent.Core.Fingerprint
-                       Network.BitTorrent.Core.NodeInfo
-                       Network.BitTorrent.Core.PeerId
-                       Network.BitTorrent.Core.PeerAddr
                        Network.BitTorrent.DHT
                        Network.BitTorrent.DHT.ContactInfo
                        Network.BitTorrent.DHT.Message
@@ -69,17 +62,13 @@ library
                        Network.BitTorrent.DHT.Session
                        Network.BitTorrent.DHT.Token
                        Network.BitTorrent.Exchange
-                       Network.BitTorrent.Exchange.Assembler
+                       Network.BitTorrent.Exchange.Bitfield
                        Network.BitTorrent.Exchange.Block
                        Network.BitTorrent.Exchange.Connection
+                       Network.BitTorrent.Exchange.Download
                        Network.BitTorrent.Exchange.Manager
                        Network.BitTorrent.Exchange.Message
-                       Network.BitTorrent.Exchange.Selection
                        Network.BitTorrent.Exchange.Session
-                       Network.BitTorrent.Exchange.Session.Metadata
-                       Network.BitTorrent.Exchange.Session.Status
-                       Network.BitTorrent.Internal.Cache
-                       Network.BitTorrent.Internal.Types
                        Network.BitTorrent.Tracker
                        Network.BitTorrent.Tracker.List
                        Network.BitTorrent.Tracker.Message
@@ -87,9 +76,23 @@ library
                        Network.BitTorrent.Tracker.RPC.HTTP
                        Network.BitTorrent.Tracker.RPC.UDP
                        Network.BitTorrent.Tracker.Session
-                       System.Torrent.FileMap
                        System.Torrent.Storage
   other-modules:       Paths_bittorrent
+  if flag(testing)
+    exposed-modules:
+                       Network.BitTorrent.Internal.Cache
+                       Network.BitTorrent.Internal.Progress
+                       Network.BitTorrent.Internal.Types
+                       System.Torrent.FileMap
+                       System.Torrent.Tree
+  else
+    other-modules:
+                       Network.BitTorrent.Internal.Cache
+                       Network.BitTorrent.Internal.Progress
+                       Network.BitTorrent.Internal.Types
+                       System.Torrent.FileMap
+                       System.Torrent.Tree
+
   build-depends:       base       == 4.*
                      , lifted-base
                      , bits-extras  >= 0.1.2
@@ -113,8 +116,8 @@ library
                      , stm           >= 2.4
 
                        -- Streaming
-                     , conduit          >= 1.0
-                     , network-conduit  >= 1.0
+                     , conduit          >= 1.1
+                     , conduit-extra    >= 1.1
                      , cereal-conduit   >= 0.5
 
                        -- * Logging
@@ -180,19 +183,9 @@ test-suite spec
   other-modules:       Spec
                        Config
 
-                       Data.Torrent.BitfieldSpec
-                       Data.Torrent.InfoHashSpec
-                       Data.Torrent.LayoutSpec
-                       Data.Torrent.MagnetSpec
-                       Data.Torrent.MetainfoSpec
-                       Data.Torrent.PieceSpec
-                       Data.Torrent.ProgressSpec
+                       Data.TorrentSpec
                        Network.BitTorrent.Client.HandleSpec
                        Network.BitTorrent.CoreSpec
-                       Network.BitTorrent.Core.FingerprintSpec
-                       Network.BitTorrent.Core.NodeInfoSpec
-                       Network.BitTorrent.Core.PeerAddrSpec
-                       Network.BitTorrent.Core.PeerIdSpec
                        Network.BitTorrent.DHTSpec
                        Network.BitTorrent.DHT.TestData
                        Network.BitTorrent.DHT.MessageSpec
@@ -201,6 +194,7 @@ test-suite spec
                        Network.BitTorrent.DHT.SessionSpec
                        Network.BitTorrent.DHT.TokenSpec
                        Network.BitTorrent.Internal.CacheSpec
+                       Network.BitTorrent.Internal.ProgressSpec
                        Network.BitTorrent.Tracker.TestData
                        Network.BitTorrent.Tracker.ListSpec
                        Network.BitTorrent.Tracker.MessageSpec
@@ -208,10 +202,11 @@ test-suite spec
                        Network.BitTorrent.Tracker.RPC.HTTPSpec
                        Network.BitTorrent.Tracker.RPC.UDPSpec
                        Network.BitTorrent.Tracker.SessionSpec
+                       Network.BitTorrent.Exchange.BitfieldSpec
                        Network.BitTorrent.Exchange.ConnectionSpec
+                       Network.BitTorrent.Exchange.DownloadSpec
                        Network.BitTorrent.Exchange.MessageSpec
                        Network.BitTorrent.Exchange.SessionSpec
-                       Network.BitTorrent.Exchange.Session.MetadataSpec
                        System.Torrent.StorageSpec
                        System.Torrent.FileMapSpec
   build-depends:       base == 4.*
@@ -228,13 +223,13 @@ test-suite spec
                      , time
 
                        -- * Serialization
-                     , aeson
                      , cereal
 
                        -- * Monads
                      , mtl
                      , resourcet
                      , conduit
+                     , conduit-extra
                      , monad-loops
                      , monad-logger
 
diff --git a/src/Data/Torrent.hs b/src/Data/Torrent.hs
index b233937b..cfc26453 100644
--- a/src/Data/Torrent.hs
+++ b/src/Data/Torrent.hs
@@ -17,23 +17,91 @@
 --   <https://wiki.theory.org/BitTorrentSpecification#Metainfo_File_Structure>
 --
 {-# LANGUAGE CPP                        #-}
+{-# LANGUAGE NamedFieldPuns             #-}
 {-# LANGUAGE FlexibleInstances          #-}
 {-# LANGUAGE OverlappingInstances       #-}
+{-# LANGUAGE MultiParamTypeClasses      #-}
 {-# LANGUAGE BangPatterns               #-}
 {-# LANGUAGE GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE StandaloneDeriving         #-}
 {-# LANGUAGE DeriveDataTypeable         #-}
+{-# LANGUAGE DeriveFunctor              #-}
+{-# LANGUAGE DeriveFoldable             #-}
+{-# LANGUAGE DeriveTraversable          #-}
 {-# LANGUAGE TemplateHaskell            #-}
 {-# OPTIONS -fno-warn-orphans           #-}
 module Data.Torrent
-       ( -- * Info dictionary
-         InfoDict (..)
-       , infoDictionary
+       ( -- * InfoHash
+         -- $infohash
+         InfoHash
+       , textToInfoHash
+       , longHex
+       , shortHex
 
-         -- ** Lenses
+         -- * File layout
+         -- ** FileInfo
+       , FileOffset
+       , FileSize
+       , FileInfo (..)
+       , fileLength
+       , filePath
+       , fileMD5Sum
+
+         -- ** Layout info
+       , LayoutInfo (..)
+       , singleFile
+       , multiFile
+       , rootDirName
+       , joinFilePath
+       , isSingleFile
+       , isMultiFile
+       , suggestedName
+       , contentLength
+       , fileCount
+       , blockCount
+
+         -- ** Flat layout info
+       , FileLayout
+       , flatLayout
+       , accumPositions
+       , fileOffset
+
+         -- ** Internal
+       , sizeInBase
+
+         -- * Pieces
+         -- ** Attributes
+       , PieceIx
+       , PieceCount
+       , PieceSize
+       , minPieceSize
+       , maxPieceSize
+       , defaultPieceSize
+       , PieceHash
+
+         -- ** Piece data
+       , Piece (..)
+       , pieceSize
+       , hashPiece
+
+         -- ** Piece control
+       , HashList (..)
+       , PieceInfo (..)
+       , pieceLength
+       , pieceHashes
+       , pieceCount
+
+         -- ** Validation
+       , pieceHash
+       , checkPieceLazy
+
+         -- * Info dictionary
+       , InfoDict (..)
        , infohash
        , layoutInfo
        , pieceInfo
        , isPrivate
+       , infoDictionary
 
          -- * Torrent file
        , Torrent(..)
@@ -50,50 +118,598 @@ module Data.Torrent
        , publisherURL
        , signature
 
-         -- * Construction
+         -- ** Utils
        , nullTorrent
-
-         -- * Mime types
        , typeTorrent
-
-         -- * File paths
        , torrentExt
        , isTorrentPath
-
-         -- * IO
        , fromFile
        , toFile
+
+         -- * Magnet
+         -- $magnet-link
+       , Magnet(..)
+       , nullMagnet
+       , simpleMagnet
+       , detailedMagnet
+       , parseMagnet
+       , renderMagnet
+
+         -- ** URN
+       , URN (..)
+       , NamespaceId
+       , btih
+       , infohashURN
+       , parseURN
+       , renderURN
        ) where
 
-import Prelude hiding (sum)
+import Prelude
 import Control.Applicative
-import qualified Crypto.Hash.SHA1 as C
 import Control.DeepSeq
 import Control.Exception
 import Control.Lens
+import Control.Monad
+import Crypto.Hash.SHA1 as SHA1
 import Data.BEncode as BE
 import Data.BEncode.Types as BE
-import           Data.ByteString as BS
-import qualified Data.ByteString.Char8 as BC (pack, unpack)
-import qualified Data.ByteString.Lazy  as BL
-import           Data.Convertible
-import           Data.Default
-import           Data.Hashable   as Hashable
-import qualified Data.List as L
-import           Data.Text as T
-import Data.Time
+import Data.Bits
+import Data.Bits.Extras
+import Data.ByteString as BS
+import Data.ByteString.Base16 as Base16
+import Data.ByteString.Base32 as Base32
+import Data.ByteString.Base64 as Base64
+import Data.ByteString.Char8 as BC (pack, unpack)
+import Data.ByteString.Lazy  as BL
+import Data.Char
+import Data.Convertible
+import Data.Default
+import Data.Foldable as F
+import Data.Hashable   as Hashable
+import Data.Int
+import Data.List as L
+import Data.Map as M
+import Data.Maybe
+import Data.Serialize as S
+import Data.String
+import Data.Text as T
+import Data.Text.Encoding as T
+import Data.Text.Read
 import Data.Time.Clock.POSIX
 import Data.Typeable
 import Network (HostName)
+import Network.HTTP.Types.QueryLike
+import Network.HTTP.Types.URI
 import Network.URI
+import Text.ParserCombinators.ReadP as P
 import Text.PrettyPrint as PP
 import Text.PrettyPrint.Class
 import System.FilePath
+import System.Posix.Types
+
+import Network.BitTorrent.Address
+
+
+{-----------------------------------------------------------------------
+--  Info hash
+-----------------------------------------------------------------------}
+-- TODO
+--
+-- data Word160 = Word160 {-# UNPACK #-} !Word64
+--                        {-# UNPACK #-} !Word64
+--                        {-# UNPACK #-} !Word32
+--
+-- newtype InfoHash = InfoHash Word160
+--
+-- reason: bytestring have overhead = 8 words, while infohash have length 20 bytes
+
+-- $infohash
+--
+-- Infohash is a unique identifier of torrent.
+
+-- | Exactly 20 bytes long SHA1 hash of the info part of torrent file.
+newtype InfoHash = InfoHash { getInfoHash :: BS.ByteString }
+  deriving (Eq, Ord, Typeable)
+
+infoHashLen :: Int
+infoHashLen = 20
+
+-- | Meaningless placeholder value.
+instance Default InfoHash where
+  def = "0123456789012345678901234567890123456789"
+
+-- | Hash raw bytes. (no encoding)
+instance Hashable InfoHash where
+  hashWithSalt s (InfoHash ih) = hashWithSalt s ih
+  {-# INLINE hashWithSalt #-}
+
+-- | Convert to\/from raw bencoded string. (no encoding)
+instance BEncode InfoHash where
+  toBEncode = toBEncode . getInfoHash
+  fromBEncode be = InfoHash <$> fromBEncode be
+
+-- | Convert to\/from raw bytestring. (no encoding)
+instance Serialize InfoHash where
+  put (InfoHash ih) = putByteString ih
+  {-# INLINE put #-}
+
+  get = InfoHash <$> getBytes infoHashLen
+  {-# INLINE get #-}
+
+-- | Convert to raw query value. (no encoding)
+instance QueryValueLike InfoHash where
+  toQueryValue (InfoHash ih) = Just ih
+  {-# INLINE toQueryValue #-}
+
+-- | Convert to base16 encoded string.
+instance Show InfoHash where
+  show (InfoHash ih) = BC.unpack (Base16.encode ih)
+
+-- | Convert to base16 encoded Doc string.
+instance Pretty InfoHash where
+  pretty = text . show
+
+-- | Read base16 encoded string.
+instance Read InfoHash where
+  readsPrec _ = readP_to_S $ do
+      str <- replicateM (infoHashLen * 2) (satisfy isHexDigit)
+      return $ InfoHash $ decodeIH str
+    where
+      decodeIH       = BS.pack . L.map fromHex . pair
+      fromHex (a, b) = read $ '0' : 'x' : a : b : []
+
+      pair (a : b : xs) = (a, b) : pair xs
+      pair _            = []
+
+-- | Convert raw bytes to info hash.
+instance Convertible BS.ByteString InfoHash where
+  safeConvert bs
+    | BS.length bs == infoHashLen = pure (InfoHash bs)
+    |          otherwise          = convError "invalid length" bs
+
+-- | Parse infohash from base16\/base32\/base64 encoded string.
+instance Convertible Text InfoHash where
+  safeConvert t
+      | 20 == hashLen = pure (InfoHash hashStr)
+      | 26 <= hashLen && hashLen <= 28 =
+        case Base64.decode hashStr of
+          Left  msg   -> convError ("invalid base64 encoding " ++ msg) t
+          Right ihStr -> safeConvert ihStr
+
+      |      hashLen == 32   =
+        case Base32.decode hashStr of
+          Left  msg   -> convError msg t
+          Right ihStr -> safeConvert ihStr
+
+      |      hashLen == 40   =
+        let (ihStr, inv) = Base16.decode hashStr
+        in if BS.length inv /= 0
+           then convError "invalid base16 encoding" t
+           else safeConvert ihStr
+
+      |        otherwise     = convError "invalid length" t
+    where
+      hashLen = BS.length hashStr
+      hashStr = T.encodeUtf8 t
+
+-- | Decode from base16\/base32\/base64 encoded string.
+instance IsString InfoHash where
+  fromString = either (error . prettyConvertError) id . safeConvert . T.pack
+
+ignoreErrorMsg :: Either a b -> Maybe b
+ignoreErrorMsg = either (const Nothing) Just
+
+-- | Tries both base16 and base32 while decoding info hash.
+--
+--  Use 'safeConvert' for detailed error messages.
+--
+textToInfoHash :: Text -> Maybe InfoHash
+textToInfoHash = ignoreErrorMsg . safeConvert
 
-import Data.Torrent.InfoHash as IH
-import Data.Torrent.Layout
-import Data.Torrent.Piece
-import Network.BitTorrent.Core.NodeInfo
+-- | Hex encode infohash to text, full length.
+longHex :: InfoHash -> Text
+longHex = T.decodeUtf8 . Base16.encode . getInfoHash
+
+-- | The same as 'longHex', but only first 7 characters.
+shortHex :: InfoHash -> Text
+shortHex = T.take 7 . longHex
+
+{-----------------------------------------------------------------------
+--  File info
+-----------------------------------------------------------------------}
+
+-- | Size of a file in bytes.
+type FileSize = FileOffset
+
+deriving instance BEncode  FileOffset
+
+-- | Contain metainfo about one single file.
+data FileInfo a = FileInfo {
+      fiLength      :: {-# UNPACK #-} !FileSize
+      -- ^ Length of the file in bytes.
+
+      -- TODO unpacked MD5 sum
+    , fiMD5Sum      :: !(Maybe BS.ByteString)
+      -- ^ 32 character long MD5 sum of the file.  Used by third-party
+      -- tools, not by bittorrent protocol itself.
+
+    , fiName        :: !a
+      -- ^ One or more string elements that together represent the
+      -- path and filename. Each element in the list corresponds to
+      -- either a directory name or (in the case of the last element)
+      -- the filename.  For example, the file:
+      --
+      --   > "dir1/dir2/file.ext"
+      --
+      --   would consist of three string elements:
+      --
+      --   > ["dir1", "dir2", "file.ext"]
+      --
+    } deriving (Show, Read, Eq, Typeable
+               , Functor, Foldable
+               )
+
+makeLensesFor
+  [ ("fiLength", "fileLength")
+  , ("fiMD5Sum", "fileMD5Sum")
+  , ("fiName"  , "filePath"  )
+  ]
+  ''FileInfo
+
+instance NFData a => NFData (FileInfo a) where
+  rnf FileInfo {..} = rnf fiName
+  {-# INLINE rnf #-}
+
+instance BEncode (FileInfo [BS.ByteString]) where
+  toBEncode FileInfo {..} = toDict $
+       "length" .=! fiLength
+    .: "md5sum" .=? fiMD5Sum
+    .: "path"   .=! fiName
+    .: endDict
+  {-# INLINE toBEncode #-}
+
+  fromBEncode = fromDict $ do
+    FileInfo <$>! "length"
+             <*>? "md5sum"
+             <*>! "path"
+  {-# INLINE fromBEncode #-}
+
+type Put a = a -> BDict -> BDict
+
+putFileInfoSingle :: Data.Torrent.Put (FileInfo BS.ByteString)
+putFileInfoSingle FileInfo {..} cont =
+       "length" .=! fiLength
+    .: "md5sum" .=? fiMD5Sum
+    .: "name"   .=! fiName
+    .: cont
+
+getFileInfoSingle :: BE.Get (FileInfo BS.ByteString)
+getFileInfoSingle = do
+    FileInfo <$>! "length"
+             <*>? "md5sum"
+             <*>! "name"
+
+instance BEncode (FileInfo BS.ByteString) where
+  toBEncode = toDict . (`putFileInfoSingle` endDict)
+  {-# INLINE toBEncode #-}
+
+  fromBEncode = fromDict getFileInfoSingle
+  {-# INLINE fromBEncode #-}
+
+instance Pretty (FileInfo BS.ByteString) where
+  pretty FileInfo {..} =
+       "Path: " <> text (T.unpack (T.decodeUtf8 fiName))
+    $$ "Size: " <> text (show fiLength)
+    $$ maybe PP.empty ppMD5 fiMD5Sum
+   where
+    ppMD5 md5 = "MD5 : " <> text (show (Base16.encode md5))
+
+-- | Join file path.
+joinFilePath :: FileInfo [BS.ByteString] -> FileInfo BS.ByteString
+joinFilePath = fmap (BS.intercalate "/")
+
+{-----------------------------------------------------------------------
+--  Layout info
+-----------------------------------------------------------------------}
+
+-- | Original (found in torrent file) layout info is either:
+--
+--     * Single file with its /name/.
+--
+--     * Multiple files with its relative file /paths/.
+--
+data LayoutInfo
+  = SingleFile
+    { -- | Single file info.
+      liFile     :: !(FileInfo BS.ByteString)
+    }
+  | MultiFile
+    { -- | List of the all files that torrent contains.
+      liFiles    :: ![FileInfo [BS.ByteString]]
+
+      -- | The /suggested/ name of the root directory in which to
+      -- store all the files.
+    , liDirName  :: !BS.ByteString
+    } deriving (Show, Read, Eq, Typeable)
+
+makeLensesFor
+  [ ("liFile"   , "singleFile" )
+  , ("liFiles"  , "multiFile"  )
+  , ("liDirName", "rootDirName")
+  ]
+  ''LayoutInfo
+
+instance NFData LayoutInfo where
+  rnf SingleFile {..} = ()
+  rnf MultiFile  {..} = rnf liFiles
+
+-- | Empty multifile layout.
+instance Default LayoutInfo where
+  def = MultiFile [] ""
+
+getLayoutInfo :: BE.Get LayoutInfo
+getLayoutInfo = single <|> multi
+  where
+    single = SingleFile <$>  getFileInfoSingle
+    multi  = MultiFile  <$>! "files" <*>! "name"
+
+putLayoutInfo :: Data.Torrent.Put LayoutInfo
+putLayoutInfo SingleFile {..} = putFileInfoSingle liFile
+putLayoutInfo MultiFile  {..} = \ cont ->
+     "files" .=! liFiles
+  .: "name"  .=! liDirName
+  .: cont
+
+instance BEncode LayoutInfo where
+  toBEncode   = toDict . (`putLayoutInfo` endDict)
+  fromBEncode = fromDict getLayoutInfo
+
+instance Pretty LayoutInfo where
+  pretty SingleFile {..} = pretty liFile
+  pretty MultiFile  {..} = vcat $ L.map (pretty . joinFilePath) liFiles
+
+-- | Test if this is single file torrent.
+isSingleFile :: LayoutInfo -> Bool
+isSingleFile SingleFile {} = True
+isSingleFile _             = False
+{-# INLINE isSingleFile #-}
+
+-- | Test if this is multifile torrent.
+isMultiFile :: LayoutInfo -> Bool
+isMultiFile MultiFile {} = True
+isMultiFile _            = False
+{-# INLINE isMultiFile #-}
+
+-- | Get name of the torrent based on the root path piece.
+suggestedName :: LayoutInfo -> BS.ByteString
+suggestedName (SingleFile FileInfo {..}) = fiName
+suggestedName  MultiFile           {..}  = liDirName
+{-# INLINE suggestedName #-}
+
+-- | Find sum of sizes of the all torrent files.
+contentLength :: LayoutInfo -> FileSize
+contentLength SingleFile { liFile  = FileInfo {..} } = fiLength
+contentLength MultiFile  { liFiles = tfs           } = L.sum (L.map fiLength tfs)
+
+-- | Get number of all files in torrent.
+fileCount :: LayoutInfo -> Int
+fileCount SingleFile {..} = 1
+fileCount MultiFile  {..} = L.length liFiles
+
+-- | Find number of blocks of the specified size. If torrent size is
+-- not a multiple of block size then the count is rounded up.
+blockCount :: Int -> LayoutInfo -> Int
+blockCount blkSize ci = contentLength ci `sizeInBase` blkSize
+
+------------------------------------------------------------------------
+
+-- | File layout specifies the order and the size of each file in the
+--   storage. Note that order of files is highly important since we
+--   coalesce all the files in the given order to get the linear block
+--   address space.
+--
+type FileLayout a = [(FilePath, a)]
+
+-- | Extract files layout from torrent info with the given root path.
+flatLayout
+  :: FilePath            -- ^ Root path for the all torrent files.
+  -> LayoutInfo          -- ^ Torrent content information.
+  -> FileLayout FileSize -- ^ The all file paths prefixed with the given root.
+flatLayout prefixPath SingleFile { liFile = FileInfo {..} }
+    = [(prefixPath </> BC.unpack fiName, fiLength)]
+flatLayout prefixPath MultiFile  {..}     = L.map mkPath liFiles
+  where   -- TODO use utf8 encoding in name
+    mkPath FileInfo {..} = (_path, fiLength)
+      where
+        _path = prefixPath </> BC.unpack liDirName
+           </> joinPath (L.map BC.unpack fiName)
+
+-- | Calculate offset of each file based on its length, incrementally.
+accumPositions :: FileLayout FileSize -> FileLayout (FileOffset, FileSize)
+accumPositions = go 0
+  where
+    go !_ [] = []
+    go !offset ((n, s) : xs) = (n, (offset, s)) : go (offset + s) xs
+
+-- | Gives global offset of a content file for a given full path.
+fileOffset :: FilePath -> FileLayout FileOffset -> Maybe FileOffset
+fileOffset = L.lookup
+{-# INLINE fileOffset #-}
+
+------------------------------------------------------------------------
+
+-- | Divide and round up.
+sizeInBase :: Integral a => a -> Int -> Int
+sizeInBase n b = fromIntegral (n `div` fromIntegral b) + align
+  where
+    align = if n `mod` fromIntegral b == 0 then 0 else 1
+{-# SPECIALIZE sizeInBase :: Int -> Int -> Int #-}
+{-# SPECIALIZE sizeInBase :: Integer -> Int -> Int #-}
+
+{-----------------------------------------------------------------------
+-- Piece attributes
+-----------------------------------------------------------------------}
+
+-- | Zero-based index of piece in torrent content.
+type PieceIx   = Int
+
+-- | Size of piece in bytes. Should be a power of 2.
+--
+--   NOTE: Have max and min size constrained to wide used
+--   semi-standard values. This bounds should be used to make decision
+--   about piece size for new torrents.
+--
+type PieceSize = Int
+
+-- | Number of pieces in torrent or a part of torrent.
+type PieceCount = Int
+
+defaultBlockSize :: Int
+defaultBlockSize = 16 * 1024
+
+-- | Optimal number of pieces in torrent.
+optimalPieceCount :: PieceCount
+optimalPieceCount = 1000
+{-# INLINE optimalPieceCount #-}
+
+-- | Piece size should not be less than this value.
+minPieceSize :: Int
+minPieceSize = defaultBlockSize * 4
+{-# INLINE minPieceSize #-}
+
+-- | To prevent transfer degradation piece size should not exceed this
+-- value.
+maxPieceSize :: Int
+maxPieceSize = 4 * 1024 * 1024
+{-# INLINE maxPieceSize #-}
+
+toPow2 :: Int -> Int
+toPow2 x = bit $ fromIntegral (leadingZeros (0 :: Int) - leadingZeros x)
+
+-- | Find the optimal piece size for a given torrent size.
+defaultPieceSize :: Int64 -> Int
+defaultPieceSize x = max minPieceSize $ min maxPieceSize $ toPow2 pc
+  where
+    pc = fromIntegral (x `div` fromIntegral optimalPieceCount)
+
+{-----------------------------------------------------------------------
+-- Piece data
+-----------------------------------------------------------------------}
+
+type PieceHash = BS.ByteString
+
+hashsize :: Int
+hashsize = 20
+{-# INLINE hashsize #-}
+
+-- TODO check if pieceLength is power of 2
+-- | Piece payload should be strict or lazy bytestring.
+data Piece a = Piece
+  { -- | Zero-based piece index in torrent.
+    pieceIndex :: {-# UNPACK #-} !PieceIx
+
+    -- | Payload.
+  , pieceData  :: !a
+  } deriving (Show, Read, Eq, Functor, Typeable)
+
+instance NFData (Piece a)
+
+-- | Payload bytes are omitted.
+instance Pretty (Piece a) where
+  pretty Piece {..} = "Piece" <+> braces ("index" <+> "=" <+> int pieceIndex)
+
+-- | Get size of piece in bytes.
+pieceSize :: Piece BL.ByteString -> PieceSize
+pieceSize Piece {..} = fromIntegral (BL.length pieceData)
+
+-- | Get piece hash.
+hashPiece :: Piece BL.ByteString -> PieceHash
+hashPiece Piece {..} = SHA1.hashlazy pieceData
+
+{-----------------------------------------------------------------------
+-- Piece control
+-----------------------------------------------------------------------}
+
+-- | A flat array of SHA1 hash for each piece.
+newtype HashList = HashList { unHashList :: BS.ByteString }
+  deriving (Show, Read, Eq, BEncode, Typeable)
+
+-- | Empty hash list.
+instance Default HashList where
+  def = HashList ""
+
+-- | Part of torrent file used for torrent content validation.
+data PieceInfo = PieceInfo
+  { piPieceLength  :: {-# UNPACK #-} !PieceSize
+    -- ^ Number of bytes in each piece.
+
+  , piPieceHashes  :: !HashList
+    -- ^ Concatenation of all 20-byte SHA1 hash values.
+  } deriving (Show, Read, Eq, Typeable)
+
+-- | Number of bytes in each piece.
+makeLensesFor [("piPieceLength", "pieceLength")] ''PieceInfo
+
+-- | Concatenation of all 20-byte SHA1 hash values.
+makeLensesFor [("piPieceHashes", "pieceHashes")] ''PieceInfo
+
+instance NFData PieceInfo
+
+instance Default PieceInfo where
+  def = PieceInfo 1 def
+
+class Lint a where
+   lint :: a -> Either String a
+
+instance Lint PieceInfo where
+  lint pinfo @ PieceInfo {..}
+    | BS.length (unHashList piPieceHashes) `rem` hashsize == 0
+    , piPieceLength >= 0 = return pinfo
+    |       otherwise    = Left undefined
+
+
+putPieceInfo :: Data.Torrent.Put PieceInfo
+putPieceInfo PieceInfo {..} cont =
+       "piece length" .=! piPieceLength
+    .: "pieces"       .=! piPieceHashes
+    .: cont
+
+getPieceInfo :: BE.Get PieceInfo
+getPieceInfo = do
+    PieceInfo <$>! "piece length"
+              <*>! "pieces"
+
+instance BEncode PieceInfo where
+  toBEncode   = toDict . (`putPieceInfo` endDict)
+  fromBEncode = fromDict getPieceInfo
+
+-- | Hashes are omitted.
+instance Pretty PieceInfo where
+  pretty  PieceInfo {..} = "Piece size: " <> int piPieceLength
+
+slice :: Int -> Int -> BS.ByteString -> BS.ByteString
+slice start len = BS.take len . BS.drop start
+{-# INLINE slice #-}
+
+-- | Extract validation hash by specified piece index.
+pieceHash :: PieceInfo -> PieceIx -> PieceHash
+pieceHash PieceInfo {..} i = slice (hashsize * i) hashsize (unHashList piPieceHashes)
+
+-- | Find count of pieces in the torrent. If torrent size is not a
+-- multiple of piece size then the count is rounded up.
+pieceCount :: PieceInfo -> PieceCount
+pieceCount PieceInfo {..} = BS.length (unHashList piPieceHashes) `quot` hashsize
+
+-- | Test if this is last piece in torrent content.
+isLastPiece :: PieceInfo -> PieceIx -> Bool
+isLastPiece ci i = pieceCount ci == succ i
+
+-- | Validate piece with metainfo hash.
+checkPieceLazy :: PieceInfo -> Piece BL.ByteString -> Bool
+checkPieceLazy pinfo @ PieceInfo {..} Piece {..}
+  = (fromIntegral (BL.length pieceData) == piPieceLength
+     || isLastPiece pinfo pieceIndex)
+  && SHA1.hashlazy pieceData == pieceHash pinfo pieceIndex
 
 {-----------------------------------------------------------------------
 --  Info dictionary
@@ -145,9 +761,9 @@ instance Default InfoDict where
 infoDictionary :: LayoutInfo -> PieceInfo -> Bool -> InfoDict
 infoDictionary li pinfo private = InfoDict ih li pinfo private
   where
-    ih = hashLazyIH $ encode $ InfoDict def li pinfo private
+    ih = hashLazyIH $ BE.encode $ InfoDict def li pinfo private
 
-getPrivate :: Get Bool
+getPrivate :: BE.Get Bool
 getPrivate = (Just True ==) <$>? "private"
 
 putPrivate :: Bool -> BDict -> BDict
@@ -156,7 +772,7 @@ putPrivate True  = \ cont -> "private" .=! True .: cont
 
 -- | Hash lazy bytestring using SHA1 algorithm.
 hashLazyIH :: BL.ByteString -> InfoHash
-hashLazyIH = either (const (error msg)) id . safeConvert . C.hashlazy
+hashLazyIH = either (const (error msg)) id . safeConvert . SHA1.hashlazy
   where
     msg = "Infohash.hash: impossible: SHA1 is always 20 bytes long"
 
@@ -172,7 +788,7 @@ instance BEncode InfoDict where
                   <*> getPieceInfo
                   <*> getPrivate
     where
-      ih = hashLazyIH (encode dict)
+      ih = hashLazyIH (BE.encode dict)
 
 ppPrivacy :: Bool -> Doc
 ppPrivacy privacy = "Privacy: " <> if privacy then "private" else "public"
@@ -189,6 +805,7 @@ instance Pretty InfoDict where
 {-----------------------------------------------------------------------
 --  Torrent info
 -----------------------------------------------------------------------}
+-- TODO add torrent file validation
 
 -- | Metainfo about particular torrent.
 data Torrent = Torrent
@@ -219,7 +836,7 @@ data Torrent = Torrent
   , tNodes        :: !(Maybe [NodeAddr HostName])
     -- ^ This key should be set to the /K closest/ nodes in the
     -- torrent generating client's routing table. Alternatively, the
-    -- key could be set to a known good 'Network.BitTorrent.Core.Node'
+    -- key could be set to a known good 'Network.BitTorrent.Address.Node'
     -- such as one operated by the person generating the torrent.
     --
     -- Please do not automatically add \"router.bittorrent.com\" to
@@ -232,7 +849,7 @@ data Torrent = Torrent
     -- authority to allow new peers onto the swarm.
 
   , tPublisherURL :: !(Maybe URI)
-  , tSignature    :: !(Maybe ByteString)
+  , tSignature    :: !(Maybe BS.ByteString)
     -- ^ The RSA signature of the info dictionary (specifically, the
     --   encrypted SHA-1 hash of the info dictionary).
     } deriving (Show, Eq, Typeable)
@@ -361,10 +978,314 @@ isTorrentPath filepath = takeExtension filepath == extSeparator : torrentExt
 fromFile :: FilePath -> IO Torrent
 fromFile filepath = do
   contents <- BS.readFile filepath
-  case decode contents of
+  case BE.decode contents of
     Right !t -> return t
     Left msg -> throwIO $ userError $ msg ++ " while reading torrent file"
 
 -- | Encode and write a .torrent file.
 toFile :: FilePath -> Torrent -> IO ()
-toFile filepath = BL.writeFile filepath . encode
+toFile filepath = BL.writeFile filepath . BE.encode
+
+{-----------------------------------------------------------------------
+--  URN
+-----------------------------------------------------------------------}
+
+-- | Namespace identifier determines the syntactic interpretation of
+-- namespace-specific string.
+type NamespaceId = [Text]
+
+-- | BitTorrent Info Hash (hence the name) namespace
+-- identifier. Namespace-specific string /should/ be a base16\/base32
+-- encoded SHA1 hash of the corresponding torrent /info/ dictionary.
+--
+btih :: NamespaceId
+btih  = ["btih"]
+
+-- | URN is pesistent location-independent identifier for
+--   resources. In particular, URNs are used represent torrent names
+--   as a part of magnet link, see 'Data.Torrent.Magnet.Magnet' for
+--   more info.
+--
+data URN = URN
+  { urnNamespace :: NamespaceId -- ^ a namespace identifier;
+  , urnString    :: Text        -- ^ a corresponding
+                                -- namespace-specific string.
+  } deriving (Eq, Ord, Typeable)
+
+-----------------------------------------------------------------------
+
+instance Convertible URN InfoHash where
+  safeConvert u @ URN {..}
+    | urnNamespace /= btih = convError "invalid namespace" u
+    |       otherwise      = safeConvert urnString
+
+-- | Make resource name for torrent with corresponding
+-- infohash. Infohash is base16 (hex) encoded.
+--
+infohashURN :: InfoHash -> URN
+infohashURN = URN btih . longHex
+
+-- | Meaningless placeholder value.
+instance Default URN where
+  def = infohashURN def
+
+------------------------------------------------------------------------
+
+-- | Render URN to its text representation.
+renderURN :: URN -> Text
+renderURN URN {..}
+  = T.intercalate ":" $ "urn" : urnNamespace ++ [urnString]
+
+instance Pretty URN where
+  pretty = text . T.unpack . renderURN
+
+instance Show URN where
+  showsPrec n = showsPrec n . T.unpack . renderURN
+
+instance QueryValueLike URN where
+  toQueryValue = toQueryValue . renderURN
+  {-# INLINE toQueryValue #-}
+
+-----------------------------------------------------------------------
+
+_unsnoc :: [a] -> Maybe ([a], a)
+_unsnoc [] = Nothing
+_unsnoc xs = Just (L.init xs, L.last xs)
+
+instance Convertible Text URN where
+  safeConvert t = case T.split (== ':') t of
+    uriScheme : body
+      | T.toLower uriScheme == "urn" ->
+        case _unsnoc body of
+          Just (namespace, val) -> pure URN
+            { urnNamespace = namespace
+            , urnString    = val
+            }
+          Nothing -> convError "missing URN string" body
+      | otherwise -> convError "invalid URN scheme" uriScheme
+    []            -> convError "missing URN scheme" t
+
+instance IsString URN where
+  fromString = either (error . prettyConvertError) id
+             . safeConvert . T.pack
+
+-- | Try to parse an URN from its text representation.
+--
+--  Use 'safeConvert' for detailed error messages.
+--
+parseURN :: Text -> Maybe URN
+parseURN = either (const Nothing) pure . safeConvert
+
+{-----------------------------------------------------------------------
+--  Magnet
+-----------------------------------------------------------------------}
+-- $magnet-link
+--
+--   Magnet URI scheme is an standard defining Magnet links. Magnet
+--   links are refer to resources by hash, in particular magnet links
+--   can refer to torrent using corresponding infohash. In this way,
+--   magnet links can be used instead of torrent files.
+--
+--   This module provides bittorrent specific implementation of magnet
+--   links.
+--
+--   For generic magnet uri scheme see:
+--   <http://magnet-uri.sourceforge.net/magnet-draft-overview.txt>,
+--   <http://www.iana.org/assignments/uri-schemes/prov/magnet>
+--
+--   Bittorrent specific details:
+--   <http://www.bittorrent.org/beps/bep_0009.html>
+--
+
+-- TODO multiple exact topics
+-- TODO render/parse supplement for URI/query
+
+-- | An URI used to identify torrent.
+data Magnet = Magnet
+  { -- | Torrent infohash hash. Can be used in DHT queries if no
+    -- 'tracker' provided.
+    exactTopic  :: !InfoHash -- TODO InfoHash -> URN?
+
+    -- | A filename for the file to download. Can be used to
+    -- display name while waiting for metadata.
+  , displayName :: Maybe Text
+
+    -- | Size of the resource in bytes.
+  , exactLength :: Maybe Integer
+
+    -- | URI pointing to manifest, e.g. a list of further items.
+  , manifest :: Maybe Text
+
+    -- | Search string.
+  , keywordTopic :: Maybe Text
+
+    -- | A source to be queried after not being able to find and
+    -- download the file in the bittorrent network in a defined
+    -- amount of time.
+  , acceptableSource :: Maybe URI
+
+    -- | Direct link to the resource.
+  , exactSource      :: Maybe URI
+
+    -- | URI to the tracker.
+  , tracker :: Maybe URI
+
+    -- | Additional or experimental parameters.
+  , supplement :: Map Text Text
+  } deriving (Eq, Ord, Typeable)
+
+instance QueryValueLike Integer where
+  toQueryValue = toQueryValue . show
+
+instance QueryValueLike URI where
+  toQueryValue = toQueryValue . show
+
+instance QueryLike Magnet where
+  toQuery Magnet {..} =
+    [ ("xt", toQueryValue $ infohashURN exactTopic)
+    , ("dn", toQueryValue displayName)
+    , ("xl", toQueryValue exactLength)
+    , ("mt", toQueryValue manifest)
+    , ("kt", toQueryValue keywordTopic)
+    , ("as", toQueryValue acceptableSource)
+    , ("xs", toQueryValue exactSource)
+    , ("tr", toQueryValue tracker)
+    ]
+
+instance QueryValueLike Magnet where
+  toQueryValue = toQueryValue . renderMagnet
+
+instance Convertible QueryText Magnet where
+  safeConvert xs = do
+      urnStr   <- getTextMsg "xt" "exact topic not defined" xs
+      infoHash <- convertVia (error "safeConvert" :: URN)  urnStr
+      return Magnet
+        { exactTopic       = infoHash
+        , displayName      = getText "dn" xs
+        , exactLength      = getText "xl" xs >>= getInt
+        , manifest         = getText "mt" xs
+        , keywordTopic     = getText "kt" xs
+        , acceptableSource = getText "as" xs >>= getURI
+        , exactSource      = getText "xs" xs >>= getURI
+        , tracker          = getText "tr" xs >>= getURI
+        , supplement       = M.empty
+        }
+    where
+      getInt    = either (const Nothing) (Just . fst) . signed decimal
+      getURI    = parseURI . T.unpack
+      getText p = join . L.lookup p
+      getTextMsg p msg ps = maybe (convError msg xs) pure $ getText p ps
+
+magnetScheme :: URI
+magnetScheme = URI
+    { uriScheme    = "magnet:"
+    , uriAuthority = Nothing
+    , uriPath      = ""
+    , uriQuery     = ""
+    , uriFragment  = ""
+    }
+
+isMagnetURI :: URI -> Bool
+isMagnetURI u = u { uriQuery = "" } == magnetScheme
+
+-- | Can be used instead of 'parseMagnet'.
+instance Convertible URI Magnet where
+  safeConvert u @ URI {..}
+    | not (isMagnetURI u) = convError "this is not a magnet link" u
+    |      otherwise      = safeConvert $ parseQueryText $ BC.pack uriQuery
+
+-- | Can be used instead of 'renderMagnet'.
+instance Convertible Magnet URI where
+  safeConvert m = pure $ magnetScheme
+    { uriQuery = BC.unpack $ renderQuery True $ toQuery m }
+
+instance Convertible String Magnet where
+  safeConvert str
+    | Just uri <- parseURI str = safeConvert uri
+    |        otherwise         = convError "unable to parse uri" str
+
+------------------------------------------------------------------------
+
+-- | Meaningless placeholder value.
+instance Default Magnet where
+  def = Magnet
+    { exactTopic       = def
+    , displayName      = Nothing
+    , exactLength      = Nothing
+    , manifest         = Nothing
+    , keywordTopic     = Nothing
+    , acceptableSource = Nothing
+    , exactSource      = Nothing
+    , tracker          = Nothing
+    , supplement       = M.empty
+    }
+
+-- | Set 'exactTopic' ('xt' param) only, other params are empty.
+nullMagnet :: InfoHash -> Magnet
+nullMagnet u = Magnet
+    { exactTopic   = u
+    , displayName  = Nothing
+    , exactLength  = Nothing
+    , manifest     = Nothing
+    , keywordTopic = Nothing
+    , acceptableSource = Nothing
+    , exactSource      = Nothing
+    , tracker    = Nothing
+    , supplement = M.empty
+    }
+
+-- | Like 'nullMagnet' but also include 'displayName' ('dn' param).
+simpleMagnet :: Torrent -> Magnet
+simpleMagnet Torrent {tInfoDict = InfoDict {..}}
+  = (nullMagnet idInfoHash)
+    { displayName = Just $ T.decodeUtf8 $ suggestedName idLayoutInfo
+    }
+
+-- | Like 'simpleMagnet' but also include 'exactLength' ('xl' param) and
+-- 'tracker' ('tr' param).
+--
+detailedMagnet :: Torrent -> Magnet
+detailedMagnet t @ Torrent {tInfoDict = InfoDict {..}, tAnnounce}
+  = (simpleMagnet t)
+    { exactLength = Just $ fromIntegral $ contentLength idLayoutInfo
+    , tracker     = tAnnounce
+    }
+
+-----------------------------------------------------------------------
+
+parseMagnetStr :: String -> Maybe Magnet
+parseMagnetStr = either (const Nothing) Just . safeConvert
+
+renderMagnetStr :: Magnet -> String
+renderMagnetStr = show . (convert :: Magnet -> URI)
+
+instance Pretty Magnet where
+  pretty = PP.text . renderMagnetStr
+
+instance Show Magnet where
+  show = renderMagnetStr
+  {-# INLINE show #-}
+
+instance Read Magnet where
+  readsPrec _ xs
+      | Just m <- parseMagnetStr mstr = [(m, rest)]
+      | otherwise = []
+    where
+      (mstr, rest) = L.break (== ' ') xs
+
+instance IsString Magnet where
+  fromString str = fromMaybe (error msg) $ parseMagnetStr str
+    where
+      msg = "unable to parse magnet: " ++ str
+
+-- | Try to parse magnet link from urlencoded string. Use
+-- 'safeConvert' to find out error location.
+--
+parseMagnet :: Text -> Maybe Magnet
+parseMagnet = parseMagnetStr . T.unpack
+{-# INLINE parseMagnet #-}
+
+-- | Render magnet link to urlencoded string
+renderMagnet :: Magnet -> Text
+renderMagnet = T.pack . renderMagnetStr
+{-# INLINE renderMagnet #-}
diff --git a/src/Data/Torrent/InfoHash.hs b/src/Data/Torrent/InfoHash.hs
deleted file mode 100644
index f322ac6f..00000000
--- a/src/Data/Torrent/InfoHash.hs
+++ /dev/null
@@ -1,164 +0,0 @@
--- |
---   Copyright   :  (c) Sam Truzjan 2013
---   License     :  BSD3
---   Maintainer  :  pxqr.sta@gmail.com
---   Stability   :  provisional
---   Portability :  portable
---
---   Infohash is a unique identifier of torrent.
---
-{-# LANGUAGE FlexibleInstances          #-}
-{-# LANGUAGE GeneralizedNewtypeDeriving #-}
-{-# LANGUAGE MultiParamTypeClasses      #-}
-{-# LANGUAGE DeriveDataTypeable         #-}
-module Data.Torrent.InfoHash
-       ( InfoHash
-
-         -- * Parsing
-       , textToInfoHash
-
-         -- * Rendering
-       , longHex
-       , shortHex
-       ) where
-
-import Control.Applicative
-import Control.Monad
-import Data.BEncode
-import Data.ByteString as BS
-import Data.ByteString.Char8 as BC
-import Data.ByteString.Base16 as Base16
-import Data.ByteString.Base32 as Base32
-import Data.ByteString.Base64 as Base64
-import Data.Char
-import Data.Convertible.Base
-import Data.Default
-import Data.List       as L
-import Data.Hashable   as Hashable
-import Data.Serialize
-import Data.String
-import Data.Text as T
-import Data.Text.Encoding as T
-import Data.Typeable
-import Network.HTTP.Types.QueryLike
-import Text.ParserCombinators.ReadP as P
-import Text.PrettyPrint
-import Text.PrettyPrint.Class
-
-
--- TODO
---
--- data Word160 = Word160 {-# UNPACK #-} !Word64
---                        {-# UNPACK #-} !Word64
---                        {-# UNPACK #-} !Word32
---
--- newtype InfoHash = InfoHash Word160
---
--- reason: bytestring have overhead = 8 words, while infohash have length 20 bytes
-
--- | Exactly 20 bytes long SHA1 hash of the info part of torrent file.
-newtype InfoHash = InfoHash { getInfoHash :: BS.ByteString }
-                   deriving (Eq, Ord, Typeable)
-
-infoHashLen :: Int
-infoHashLen = 20
-
--- | Meaningless placeholder value.
-instance Default InfoHash where
-  def = "0123456789012345678901234567890123456789"
-
--- | Hash raw bytes. (no encoding)
-instance Hashable InfoHash where
-  hashWithSalt s (InfoHash ih) = hashWithSalt s ih
-  {-# INLINE hashWithSalt #-}
-
--- | Convert to\/from raw bencoded string. (no encoding)
-instance BEncode InfoHash where
-  toBEncode = toBEncode . getInfoHash
-  fromBEncode be = InfoHash <$> fromBEncode be
-
--- | Convert to\/from raw bytestring. (no encoding)
-instance Serialize InfoHash where
-  put (InfoHash ih) = putByteString ih
-  {-# INLINE put #-}
-
-  get = InfoHash <$> getBytes infoHashLen
-  {-# INLINE get #-}
-
--- | Convert to raw query value. (no encoding)
-instance QueryValueLike InfoHash where
-  toQueryValue (InfoHash ih) = Just ih
-  {-# INLINE toQueryValue #-}
-
--- | Convert to base16 encoded string.
-instance Show InfoHash where
-  show (InfoHash ih) = BC.unpack (Base16.encode ih)
-
--- | Convert to base16 encoded Doc string.
-instance Pretty InfoHash where
-  pretty = text . show
-
--- | Read base16 encoded string.
-instance Read InfoHash where
-  readsPrec _ = readP_to_S $ do
-      str <- replicateM (infoHashLen * 2) (satisfy isHexDigit)
-      return $ InfoHash $ decodeIH str
-    where
-      decodeIH       = BS.pack . L.map fromHex . pair
-      fromHex (a, b) = read $ '0' : 'x' : a : b : []
-
-      pair (a : b : xs) = (a, b) : pair xs
-      pair _            = []
-
--- | Convert raw bytes to info hash.
-instance Convertible BS.ByteString InfoHash where
-  safeConvert bs
-    | BS.length bs == infoHashLen = pure (InfoHash bs)
-    |          otherwise          = convError "invalid length" bs
-
--- | Parse infohash from base16\/base32\/base64 encoded string.
-instance Convertible Text InfoHash where
-  safeConvert t
-      | 20 == hashLen = pure (InfoHash hashStr)
-      | 26 <= hashLen && hashLen <= 28 =
-        case Base64.decode hashStr of
-          Left  msg   -> convError ("invalid base64 encoding " ++ msg) t
-          Right ihStr -> safeConvert ihStr
-
-      |      hashLen == 32   =
-        case Base32.decode hashStr of
-          Left  msg   -> convError msg t
-          Right ihStr -> safeConvert ihStr
-
-      |      hashLen == 40   =
-        let (ihStr, inv) = Base16.decode hashStr
-        in if BS.length inv /= 0
-           then convError "invalid base16 encoding" t
-           else safeConvert ihStr
-
-      |        otherwise     = convError "invalid length" t
-    where
-      hashLen = BS.length hashStr
-      hashStr = T.encodeUtf8 t
-
--- | Decode from base16\/base32\/base64 encoded string.
-instance IsString InfoHash where
-  fromString = either (error . prettyConvertError) id . safeConvert . T.pack
-
-ignoreErrorMsg :: Either a b -> Maybe b
-ignoreErrorMsg = either (const Nothing) Just
-
--- | Tries both base16 and base32 while decoding info hash.
---
---  Use 'safeConvert' for detailed error messages.
---
-textToInfoHash :: Text -> Maybe InfoHash
-textToInfoHash = ignoreErrorMsg . safeConvert
-
--- | Hex encode infohash to text, full length.
-longHex :: InfoHash -> Text
-longHex = T.decodeUtf8 . Base16.encode . getInfoHash
-
--- | The same as 'longHex', but only first 7 characters.
-shortHex :: InfoHash -> Text
-shortHex = T.take 7 . longHex
diff --git a/src/Data/Torrent/Layout.hs b/src/Data/Torrent/Layout.hs
deleted file mode 100644
index cc529840..00000000
--- a/src/Data/Torrent/Layout.hs
+++ /dev/null
@@ -1,321 +0,0 @@
--- |
---   Copyright   :  (c) Sam Truzjan 2013
---   License     :  BSD3
---   Maintainer  :  pxqr.sta@gmail.com
---   Stability   :  experimental
---   Portability :  portable
---
---   Layout of files in torrent.
---
-{-# LANGUAGE BangPatterns               #-}
-{-# LANGUAGE FlexibleInstances          #-}
-{-# LANGUAGE StandaloneDeriving         #-}
-{-# LANGUAGE GeneralizedNewtypeDeriving #-}
-{-# LANGUAGE DeriveDataTypeable         #-}
-{-# LANGUAGE DeriveFunctor              #-}
-{-# LANGUAGE DeriveFoldable             #-}
-{-# LANGUAGE DeriveTraversable          #-}
-{-# LANGUAGE TemplateHaskell            #-}
-{-# OPTIONS  -fno-warn-orphans          #-}
-module Data.Torrent.Layout
-       ( -- * File attributes
-         FileOffset
-       , FileSize
-
-         -- * Single file info
-       , FileInfo (..)
-
-         -- ** Lens
-       , fileLength
-       , filePath
-       , fileMD5Sum
-
-         -- * File layout
-       , LayoutInfo (..)
-       , joinFilePath
-
-         -- ** Lens
-       , singleFile
-       , multiFile
-       , rootDirName
-
-         -- ** Predicates
-       , isSingleFile
-       , isMultiFile
-
-         -- ** Query
-       , suggestedName
-       , contentLength
-       , fileCount
-       , blockCount
-
-         -- * Flat file layout
-       , FileLayout
-       , flatLayout
-       , accumPositions
-       , fileOffset
-
-         -- * Internal
-       , sizeInBase
-       , getLayoutInfo
-       , putLayoutInfo
-       ) where
-
-import Control.Applicative
-import Control.DeepSeq
-import Control.Lens
-import Data.BEncode
-import Data.BEncode.Types
-import Data.ByteString as BS
-import Data.ByteString.Base16 as Base16
-import Data.ByteString.Char8 as BC
-import Data.Default
-import Data.Foldable as F
-import Data.List as L
-import Data.Text as T
-import Data.Text.Encoding as T
-import Data.Typeable
-import Text.PrettyPrint as PP
-import Text.PrettyPrint.Class
-import System.FilePath
-import System.Posix.Types
-
-{-----------------------------------------------------------------------
---  File attribytes
------------------------------------------------------------------------}
-
--- | Size of a file in bytes.
-type FileSize = FileOffset
-
-deriving instance BEncode  FileOffset
-
-{-----------------------------------------------------------------------
---  File info both either from info dict or file list
------------------------------------------------------------------------}
-
--- | Contain metainfo about one single file.
-data FileInfo a = FileInfo {
-      fiLength      :: {-# UNPACK #-} !FileSize
-      -- ^ Length of the file in bytes.
-
-      -- TODO unpacked MD5 sum
-    , fiMD5Sum      :: !(Maybe ByteString)
-      -- ^ 32 character long MD5 sum of the file.  Used by third-party
-      -- tools, not by bittorrent protocol itself.
-
-    , fiName        :: !a
-      -- ^ One or more string elements that together represent the
-      -- path and filename. Each element in the list corresponds to
-      -- either a directory name or (in the case of the last element)
-      -- the filename.  For example, the file:
-      --
-      --   > "dir1/dir2/file.ext"
-      --
-      --   would consist of three string elements:
-      --
-      --   > ["dir1", "dir2", "file.ext"]
-      --
-    } deriving (Show, Read, Eq, Typeable
-               , Functor, Foldable
-               )
-
-makeLensesFor
-  [ ("fiLength", "fileLength")
-  , ("fiMD5Sum", "fileMD5Sum")
-  , ("fiName"  , "filePath"  )
-  ]
-  ''FileInfo
-
-instance NFData a => NFData (FileInfo a) where
-  rnf FileInfo {..} = rnf fiName
-  {-# INLINE rnf #-}
-
-instance BEncode (FileInfo [ByteString]) where
-  toBEncode FileInfo {..} = toDict $
-       "length" .=! fiLength
-    .: "md5sum" .=? fiMD5Sum
-    .: "path"   .=! fiName
-    .: endDict
-  {-# INLINE toBEncode #-}
-
-  fromBEncode = fromDict $ do
-    FileInfo <$>! "length"
-             <*>? "md5sum"
-             <*>! "path"
-  {-# INLINE fromBEncode #-}
-
-type Put a = a -> BDict -> BDict
-
-putFileInfoSingle :: Put (FileInfo ByteString)
-putFileInfoSingle FileInfo {..} cont =
-       "length" .=! fiLength
-    .: "md5sum" .=? fiMD5Sum
-    .: "name"   .=! fiName
-    .: cont
-
-getFileInfoSingle :: Get (FileInfo ByteString)
-getFileInfoSingle = do
-    FileInfo <$>! "length"
-             <*>? "md5sum"
-             <*>! "name"
-
-instance BEncode (FileInfo ByteString) where
-  toBEncode = toDict . (`putFileInfoSingle` endDict)
-  {-# INLINE toBEncode #-}
-
-  fromBEncode = fromDict getFileInfoSingle
-  {-# INLINE fromBEncode #-}
-
-instance Pretty (FileInfo BS.ByteString) where
-  pretty FileInfo {..} =
-       "Path: " <> text (T.unpack (T.decodeUtf8 fiName))
-    $$ "Size: " <> text (show fiLength)
-    $$ maybe PP.empty ppMD5 fiMD5Sum
-   where
-    ppMD5 md5 = "MD5 : " <> text (show (Base16.encode md5))
-
--- | Join file path.
-joinFilePath :: FileInfo [ByteString] -> FileInfo ByteString
-joinFilePath = fmap (BS.intercalate "/")
-
-{-----------------------------------------------------------------------
---  Original torrent file layout info
------------------------------------------------------------------------}
-
--- | Original (found in torrent file) layout info is either:
---
---     * Single file with its /name/.
---
---     * Multiple files with its relative file /paths/.
---
-data LayoutInfo
-  = SingleFile
-    { -- | Single file info.
-      liFile     :: !(FileInfo ByteString)
-    }
-  | MultiFile
-    { -- | List of the all files that torrent contains.
-      liFiles    :: ![FileInfo [ByteString]]
-
-      -- | The /suggested/ name of the root directory in which to
-      -- store all the files.
-    , liDirName  :: !ByteString
-    } deriving (Show, Read, Eq, Typeable)
-
-makeLensesFor
-  [ ("liFile"   , "singleFile" )
-  , ("liFiles"  , "multiFile"  )
-  , ("liDirName", "rootDirName")
-  ]
-  ''LayoutInfo
-
-instance NFData LayoutInfo where
-  rnf SingleFile {..} = ()
-  rnf MultiFile  {..} = rnf liFiles
-
--- | Empty multifile layout.
-instance Default LayoutInfo where
-  def = MultiFile [] ""
-
-getLayoutInfo :: Get LayoutInfo
-getLayoutInfo = single <|> multi
-  where
-    single = SingleFile <$>  getFileInfoSingle
-    multi  = MultiFile  <$>! "files" <*>! "name"
-
-putLayoutInfo :: Put LayoutInfo
-putLayoutInfo SingleFile {..} = putFileInfoSingle liFile
-putLayoutInfo MultiFile  {..} = \ cont ->
-     "files" .=! liFiles
-  .: "name"  .=! liDirName
-  .: cont
-
-instance BEncode LayoutInfo where
-  toBEncode   = toDict . (`putLayoutInfo` endDict)
-  fromBEncode = fromDict getLayoutInfo
-
-instance Pretty LayoutInfo where
-  pretty SingleFile {..} = pretty liFile
-  pretty MultiFile  {..} = vcat $ L.map (pretty . joinFilePath) liFiles
-
--- | Test if this is single file torrent.
-isSingleFile :: LayoutInfo -> Bool
-isSingleFile SingleFile {} = True
-isSingleFile _             = False
-{-# INLINE isSingleFile #-}
-
--- | Test if this is multifile torrent.
-isMultiFile :: LayoutInfo -> Bool
-isMultiFile MultiFile {} = True
-isMultiFile _            = False
-{-# INLINE isMultiFile #-}
-
--- | Get name of the torrent based on the root path piece.
-suggestedName :: LayoutInfo -> ByteString
-suggestedName (SingleFile FileInfo {..}) = fiName
-suggestedName  MultiFile           {..}  = liDirName
-{-# INLINE suggestedName #-}
-
--- | Find sum of sizes of the all torrent files.
-contentLength :: LayoutInfo -> FileSize
-contentLength SingleFile { liFile  = FileInfo {..} } = fiLength
-contentLength MultiFile  { liFiles = tfs           } = L.sum (L.map fiLength tfs)
-
--- | Get number of all files in torrent.
-fileCount :: LayoutInfo -> Int
-fileCount SingleFile {..} = 1
-fileCount MultiFile  {..} = L.length liFiles
-
--- | Find number of blocks of the specified size. If torrent size is
--- not a multiple of block size then the count is rounded up.
-blockCount :: Int -> LayoutInfo -> Int
-blockCount blkSize ci = contentLength ci `sizeInBase` blkSize
-
-{-----------------------------------------------------------------------
---  Flat layout
------------------------------------------------------------------------}
-
--- | File layout specifies the order and the size of each file in the
---   storage. Note that order of files is highly important since we
---   coalesce all the files in the given order to get the linear block
---   address space.
---
-type FileLayout a = [(FilePath, a)]
-
--- | Extract files layout from torrent info with the given root path.
-flatLayout
-  :: FilePath            -- ^ Root path for the all torrent files.
-  -> LayoutInfo          -- ^ Torrent content information.
-  -> FileLayout FileSize -- ^ The all file paths prefixed with the given root.
-flatLayout prefixPath SingleFile { liFile = FileInfo {..} }
-    = [(prefixPath </> BC.unpack fiName, fiLength)]
-flatLayout prefixPath MultiFile  {..}     = L.map mkPath liFiles
-  where   -- TODO use utf8 encoding in name
-    mkPath FileInfo {..} = (path, fiLength)
-      where
-        path = prefixPath </> BC.unpack liDirName
-           </> joinPath (L.map BC.unpack fiName)
-
--- | Calculate offset of each file based on its length, incrementally.
-accumPositions :: FileLayout FileSize -> FileLayout (FileOffset, FileSize)
-accumPositions = go 0
-  where
-    go !_ [] = []
-    go !offset ((n, s) : xs) = (n, (offset, s)) : go (offset + s) xs
-
--- | Gives global offset of a content file for a given full path.
-fileOffset :: FilePath -> FileLayout FileOffset -> Maybe FileOffset
-fileOffset = lookup
-{-# INLINE fileOffset #-}
-
-{-----------------------------------------------------------------------
--- Internal utilities
------------------------------------------------------------------------}
-
--- | Divide and round up.
-sizeInBase :: Integral a => a -> Int -> Int
-sizeInBase n b = fromIntegral (n `div` fromIntegral b) + align
-  where
-    align = if n `mod` fromIntegral b == 0 then 0 else 1
-{-# SPECIALIZE sizeInBase :: Int -> Int -> Int #-}
-{-# SPECIALIZE sizeInBase :: Integer -> Int -> Int #-}
diff --git a/src/Data/Torrent/Magnet.hs b/src/Data/Torrent/Magnet.hs
deleted file mode 100644
index aad0debe..00000000
--- a/src/Data/Torrent/Magnet.hs
+++ /dev/null
@@ -1,372 +0,0 @@
--- |
---   Copyright   :  (c) Sam Truzjan 2013
---   License     :  BSD3
---   Maintainer  :  pxqr.sta@gmail.com
---   Stability   :  provisional
---   Portability :  portable
---
---   Magnet URI scheme is an standard defining Magnet links. Magnet
---   links are refer to resources by hash, in particular magnet links
---   can refer to torrent using corresponding infohash. In this way,
---   magnet links can be used instead of torrent files.
---
---   This module provides bittorrent specific implementation of magnet
---   links.
---
---   For generic magnet uri scheme see:
---   <http://magnet-uri.sourceforge.net/magnet-draft-overview.txt>,
---   <http://www.iana.org/assignments/uri-schemes/prov/magnet>
---
---   Bittorrent specific details:
---   <http://www.bittorrent.org/beps/bep_0009.html>
---
-{-# LANGUAGE NamedFieldPuns        #-}
-{-# LANGUAGE FlexibleInstances     #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE TypeSynonymInstances  #-}
-{-# LANGUAGE DeriveDataTypeable    #-}
-{-# OPTIONS -fno-warn-orphans      #-}
-module Data.Torrent.Magnet
-       ( -- * Magnet
-         Magnet(..)
-
-         -- ** Construction
-       , nullMagnet
-       , simpleMagnet
-       , detailedMagnet
-
-         -- ** Conversion
-       , parseMagnet
-       , renderMagnet
-
-         -- * URN
-       , URN (..)
-
-         -- ** Namespaces
-       , NamespaceId
-       , btih
-
-         -- ** Construction
-       , infohashURN
-
-         -- ** Conversion
-       , parseURN
-       , renderURN
-       ) where
-
-import Control.Applicative
-import Control.Monad
-import Data.ByteString.Char8 as BC
-import Data.Convertible
-import Data.Default
-import Data.Map as M
-import Data.Maybe
-import Data.List as L
-import Data.String
-import Data.Text as T
-import Data.Text.Encoding as T
-import Data.Text.Read
-import Data.Typeable
-import Network.HTTP.Types.QueryLike
-import Network.HTTP.Types.URI
-import Network.URI
-import Text.PrettyPrint as PP
-import Text.PrettyPrint.Class
-
-import Data.Torrent
-import Data.Torrent.InfoHash
-import Data.Torrent.Layout
-
-
--- | Namespace identifier determines the syntactic interpretation of
--- namespace-specific string.
-type NamespaceId = [Text]
-
--- | BitTorrent Info Hash (hence the name) namespace
--- identifier. Namespace-specific string /should/ be a base16\/base32
--- encoded SHA1 hash of the corresponding torrent /info/ dictionary.
---
-btih :: NamespaceId
-btih  = ["btih"]
-
--- | URN is pesistent location-independent identifier for
---   resources. In particular, URNs are used represent torrent names
---   as a part of magnet link, see 'Data.Torrent.Magnet.Magnet' for
---   more info.
---
-data URN = URN
-  { urnNamespace :: NamespaceId -- ^ a namespace identifier;
-  , urnString    :: Text        -- ^ a corresponding
-                                -- namespace-specific string.
-  } deriving (Eq, Ord, Typeable)
-
-{-----------------------------------------------------------------------
---  URN to infohash convertion
------------------------------------------------------------------------}
-
-instance Convertible URN InfoHash where
-  safeConvert u @ URN {..}
-    | urnNamespace /= btih = convError "invalid namespace" u
-    |       otherwise      = safeConvert urnString
-
--- | Make resource name for torrent with corresponding
--- infohash. Infohash is base16 (hex) encoded.
---
-infohashURN :: InfoHash -> URN
-infohashURN = URN btih . longHex
-
--- | Meaningless placeholder value.
-instance Default URN where
-  def = infohashURN def
-
-{-----------------------------------------------------------------------
---  URN Rendering
------------------------------------------------------------------------}
-
--- | Render URN to its text representation.
-renderURN :: URN -> Text
-renderURN URN {..}
-  = T.intercalate ":" $ "urn" : urnNamespace ++ [urnString]
-
-instance Pretty URN where
-  pretty = text . T.unpack . renderURN
-
-instance Show URN where
-  showsPrec n = showsPrec n . T.unpack . renderURN
-
-instance QueryValueLike URN where
-  toQueryValue = toQueryValue . renderURN
-  {-# INLINE toQueryValue #-}
-
-{-----------------------------------------------------------------------
---  URN Parsing
------------------------------------------------------------------------}
-
-unsnoc :: [a] -> Maybe ([a], a)
-unsnoc [] = Nothing
-unsnoc xs = Just (L.init xs, L.last xs)
-
-instance Convertible Text URN where
-  safeConvert t = case T.split (== ':') t of
-    uriScheme : body
-      | T.toLower uriScheme == "urn" ->
-        case unsnoc body of
-          Just (namespace, val) -> pure URN
-            { urnNamespace = namespace
-            , urnString    = val
-            }
-          Nothing -> convError "missing URN string" body
-      | otherwise -> convError "invalid URN scheme" uriScheme
-    []            -> convError "missing URN scheme" t
-
-instance IsString URN where
-  fromString = either (error . prettyConvertError) id
-             . safeConvert . T.pack
-
--- | Try to parse an URN from its text representation.
---
---  Use 'safeConvert' for detailed error messages.
---
-parseURN :: Text -> Maybe URN
-parseURN = either (const Nothing) pure . safeConvert
-
-{-----------------------------------------------------------------------
---  Magnet
------------------------------------------------------------------------}
-
--- TODO multiple exact topics
--- TODO render/parse supplement for URI/query
-
--- | An URI used to identify torrent.
-data Magnet = Magnet
-  { -- | Torrent infohash hash. Can be used in DHT queries if no
-    -- 'tracker' provided.
-    exactTopic  :: !InfoHash -- TODO InfoHash -> URN?
-
-    -- | A filename for the file to download. Can be used to
-    -- display name while waiting for metadata.
-  , displayName :: Maybe Text
-
-    -- | Size of the resource in bytes.
-  , exactLength :: Maybe Integer
-
-    -- | URI pointing to manifest, e.g. a list of further items.
-  , manifest :: Maybe Text
-
-    -- | Search string.
-  , keywordTopic :: Maybe Text
-
-    -- | A source to be queried after not being able to find and
-    -- download the file in the bittorrent network in a defined
-    -- amount of time.
-  , acceptableSource :: Maybe URI
-
-    -- | Direct link to the resource.
-  , exactSource      :: Maybe URI
-
-    -- | URI to the tracker.
-  , tracker :: Maybe URI
-
-    -- | Additional or experimental parameters.
-  , supplement :: Map Text Text
-  } deriving (Eq, Ord, Typeable)
-
-instance QueryValueLike Integer where
-  toQueryValue = toQueryValue . show
-
-instance QueryValueLike URI where
-  toQueryValue = toQueryValue . show
-
-instance QueryLike Magnet where
-  toQuery Magnet {..} =
-    [ ("xt", toQueryValue $ infohashURN exactTopic)
-    , ("dn", toQueryValue displayName)
-    , ("xl", toQueryValue exactLength)
-    , ("mt", toQueryValue manifest)
-    , ("kt", toQueryValue keywordTopic)
-    , ("as", toQueryValue acceptableSource)
-    , ("xs", toQueryValue exactSource)
-    , ("tr", toQueryValue tracker)
-    ]
-
-instance QueryValueLike Magnet where
-  toQueryValue = toQueryValue . renderMagnet
-
-instance Convertible QueryText Magnet where
-  safeConvert xs = do
-      urnStr   <- getTextMsg "xt" "exact topic not defined" xs
-      infoHash <- convertVia (error "safeConvert" :: URN)  urnStr
-      return Magnet
-        { exactTopic       = infoHash
-        , displayName      = getText "dn" xs
-        , exactLength      = getText "xl" xs >>= getInt
-        , manifest         = getText "mt" xs
-        , keywordTopic     = getText "kt" xs
-        , acceptableSource = getText "as" xs >>= getURI
-        , exactSource      = getText "xs" xs >>= getURI
-        , tracker          = getText "tr" xs >>= getURI
-        , supplement       = M.empty
-        }
-    where
-      getInt    = either (const Nothing) (Just . fst) . signed decimal
-      getURI    = parseURI . T.unpack
-      getText p = join . L.lookup p
-      getTextMsg p msg ps = maybe (convError msg xs) pure $ getText p ps
-
-magnetScheme :: URI
-magnetScheme = URI
-    { uriScheme    = "magnet:"
-    , uriAuthority = Nothing
-    , uriPath      = ""
-    , uriQuery     = ""
-    , uriFragment  = ""
-    }
-
-isMagnetURI :: URI -> Bool
-isMagnetURI u = u { uriQuery = "" } == magnetScheme
-
--- | Can be used instead of 'parseMagnet'.
-instance Convertible URI Magnet where
-  safeConvert u @ URI {..}
-    | not (isMagnetURI u) = convError "this is not a magnet link" u
-    |      otherwise      = safeConvert $ parseQueryText $ BC.pack uriQuery
-
--- | Can be used instead of 'renderMagnet'.
-instance Convertible Magnet URI where
-  safeConvert m = pure $ magnetScheme
-    { uriQuery = BC.unpack $ renderQuery True $ toQuery m }
-
-instance Convertible String Magnet where
-  safeConvert str
-    | Just uri <- parseURI str = safeConvert uri
-    |        otherwise         = convError "unable to parse uri" str
-
-{-----------------------------------------------------------------------
---  Magnet Construction
------------------------------------------------------------------------}
-
--- | Meaningless placeholder value.
-instance Default Magnet where
-  def = Magnet
-    { exactTopic       = def
-    , displayName      = Nothing
-    , exactLength      = Nothing
-    , manifest         = Nothing
-    , keywordTopic     = Nothing
-    , acceptableSource = Nothing
-    , exactSource      = Nothing
-    , tracker          = Nothing
-    , supplement       = M.empty
-    }
-
--- | Set 'exactTopic' ('xt' param) only, other params are empty.
-nullMagnet :: InfoHash -> Magnet
-nullMagnet u = Magnet
-    { exactTopic   = u
-    , displayName  = Nothing
-    , exactLength  = Nothing
-    , manifest     = Nothing
-    , keywordTopic = Nothing
-    , acceptableSource = Nothing
-    , exactSource      = Nothing
-    , tracker    = Nothing
-    , supplement = M.empty
-    }
-
--- | Like 'nullMagnet' but also include 'displayName' ('dn' param).
-simpleMagnet :: Torrent -> Magnet
-simpleMagnet Torrent {tInfoDict = InfoDict {..}}
-  = (nullMagnet idInfoHash)
-    { displayName = Just $ T.decodeUtf8 $ suggestedName idLayoutInfo
-    }
-
--- | Like 'simpleMagnet' but also include 'exactLength' ('xl' param) and
--- 'tracker' ('tr' param).
---
-detailedMagnet :: Torrent -> Magnet
-detailedMagnet t @ Torrent {tInfoDict = InfoDict {..}, tAnnounce}
-  = (simpleMagnet t)
-    { exactLength = Just $ fromIntegral $ contentLength idLayoutInfo
-    , tracker     = tAnnounce
-    }
-
-{-----------------------------------------------------------------------
---  Magnet Conversion
------------------------------------------------------------------------}
-
-parseMagnetStr :: String -> Maybe Magnet
-parseMagnetStr = either (const Nothing) Just . safeConvert
-
-renderMagnetStr :: Magnet -> String
-renderMagnetStr = show . (convert :: Magnet -> URI)
-
-instance Pretty Magnet where
-  pretty = PP.text . renderMagnetStr
-
-instance Show Magnet where
-  show = renderMagnetStr
-  {-# INLINE show #-}
-
-instance Read Magnet where
-  readsPrec _ xs
-      | Just m <- parseMagnetStr mstr = [(m, rest)]
-      | otherwise = []
-    where
-      (mstr, rest) = L.break (== ' ') xs
-
-instance IsString Magnet where
-  fromString str = fromMaybe (error msg) $ parseMagnetStr str
-    where
-      msg = "unable to parse magnet: " ++ str
-
--- | Try to parse magnet link from urlencoded string. Use
--- 'safeConvert' to find out error location.
---
-parseMagnet :: Text -> Maybe Magnet
-parseMagnet = parseMagnetStr . T.unpack
-{-# INLINE parseMagnet #-}
-
--- | Render magnet link to urlencoded string
-renderMagnet :: Magnet -> Text
-renderMagnet = T.pack . renderMagnetStr
-{-# INLINE renderMagnet #-}
diff --git a/src/Data/Torrent/Piece.hs b/src/Data/Torrent/Piece.hs
deleted file mode 100644
index d4b2c399..00000000
--- a/src/Data/Torrent/Piece.hs
+++ /dev/null
@@ -1,232 +0,0 @@
--- |
---   Copyright   :  (c) Sam Truzjan 2013
---   License     :  BSD3
---   Maintainer  :  pxqr.sta@gmail.com
---   Stability   :  experimental
---   Portability :  portable
---
---   Pieces are used to validate torrent content.
---
-{-# LANGUAGE TemplateHaskell            #-}
-{-# LANGUAGE DeriveDataTypeable         #-}
-{-# LANGUAGE DeriveFunctor              #-}
-{-# LANGUAGE GeneralizedNewtypeDeriving #-}
-module Data.Torrent.Piece
-       ( -- * Piece attributes
-         PieceIx
-       , PieceCount
-       , PieceSize
-       , minPieceSize
-       , maxPieceSize
-       , defaultPieceSize
-       , PieceHash
-
-         -- * Piece data
-       , Piece (..)
-       , pieceSize
-       , hashPiece
-
-         -- * Piece control
-       , HashList (..)
-       , PieceInfo (..)
-       , pieceCount
-
-         -- * Lens
-       , pieceLength
-       , pieceHashes
-
-         -- * Validation
-       , pieceHash
-       , checkPieceLazy
-
-         -- * Internal
-       , getPieceInfo
-       , putPieceInfo
-       ) where
-
-import Control.DeepSeq
-import Control.Lens
-import qualified Crypto.Hash.SHA1 as SHA1
-import Data.BEncode
-import Data.BEncode.Types
-import Data.Bits
-import Data.Bits.Extras
-import           Data.ByteString as BS
-import qualified Data.ByteString.Lazy as BL
-import qualified Data.ByteString.Base64 as Base64
-import Data.Default
-import Data.Int
-import Data.Text.Encoding as T
-import Data.Typeable
-import Text.PrettyPrint
-import Text.PrettyPrint.Class
-
-
--- TODO add torrent file validation
-class Lint a where
-   lint :: a -> Either String a
-
---class Validation a where
---  validate :: PieceInfo -> Piece a -> Bool
-
-{-----------------------------------------------------------------------
--- Piece attributes
------------------------------------------------------------------------}
-
--- | Zero-based index of piece in torrent content.
-type PieceIx   = Int
-
--- | Size of piece in bytes. Should be a power of 2.
---
---   NOTE: Have max and min size constrained to wide used
---   semi-standard values. This bounds should be used to make decision
---   about piece size for new torrents.
---
-type PieceSize = Int
-
--- | Number of pieces in torrent or a part of torrent.
-type PieceCount = Int
-
-defaultBlockSize :: Int
-defaultBlockSize = 16 * 1024
-
--- | Optimal number of pieces in torrent.
-optimalPieceCount :: PieceCount
-optimalPieceCount = 1000
-{-# INLINE optimalPieceCount #-}
-
--- | Piece size should not be less than this value.
-minPieceSize :: Int
-minPieceSize = defaultBlockSize * 4
-{-# INLINE minPieceSize #-}
-
--- | To prevent transfer degradation piece size should not exceed this
--- value.
-maxPieceSize :: Int
-maxPieceSize = 4 * 1024 * 1024
-{-# INLINE maxPieceSize #-}
-
-toPow2 :: Int -> Int
-toPow2 x = bit $ fromIntegral (leadingZeros (0 :: Int) - leadingZeros x)
-
--- | Find the optimal piece size for a given torrent size.
-defaultPieceSize :: Int64 -> Int
-defaultPieceSize x = max minPieceSize $ min maxPieceSize $ toPow2 pc
-  where
-    pc = fromIntegral (x `div` fromIntegral optimalPieceCount)
-
-{-----------------------------------------------------------------------
--- Piece data
------------------------------------------------------------------------}
-
-type PieceHash = ByteString
-
-hashsize :: Int
-hashsize = 20
-{-# INLINE hashsize #-}
-
--- TODO check if pieceLength is power of 2
--- | Piece payload should be strict or lazy bytestring.
-data Piece a = Piece
-  { -- | Zero-based piece index in torrent.
-    pieceIndex :: {-# UNPACK #-} !PieceIx
-
-    -- | Payload.
-  , pieceData  :: !a
-  } deriving (Show, Read, Eq, Functor, Typeable)
-
-instance NFData (Piece a)
-
--- | Payload bytes are omitted.
-instance Pretty (Piece a) where
-  pretty Piece {..} = "Piece" <+> braces ("index" <+> "=" <+> int pieceIndex)
-
--- | Get size of piece in bytes.
-pieceSize :: Piece BL.ByteString -> PieceSize
-pieceSize Piece {..} = fromIntegral (BL.length pieceData)
-
--- | Get piece hash.
-hashPiece :: Piece BL.ByteString -> PieceHash
-hashPiece Piece {..} = SHA1.hashlazy pieceData
-
-{-----------------------------------------------------------------------
--- Piece control
------------------------------------------------------------------------}
-
--- | A flat array of SHA1 hash for each piece.
-newtype HashList = HashList { unHashList :: ByteString }
-  deriving (Show, Read, Eq, BEncode, Typeable)
-
--- | Empty hash list.
-instance Default HashList where
-  def = HashList ""
-
--- | Part of torrent file used for torrent content validation.
-data PieceInfo = PieceInfo
-  { piPieceLength  :: {-# UNPACK #-} !PieceSize
-    -- ^ Number of bytes in each piece.
-
-  , piPieceHashes  :: !HashList
-    -- ^ Concatenation of all 20-byte SHA1 hash values.
-  } deriving (Show, Read, Eq, Typeable)
-
--- | Number of bytes in each piece.
-makeLensesFor [("piPieceLength", "pieceLength")] ''PieceInfo
-
--- | Concatenation of all 20-byte SHA1 hash values.
-makeLensesFor [("piPieceHashes", "pieceHashes")] ''PieceInfo
-
-instance NFData PieceInfo
-
-instance Default PieceInfo where
-  def = PieceInfo 1 def
-
-instance Lint PieceInfo where
-  lint pinfo @ PieceInfo {..}
-    | BS.length (unHashList piPieceHashes) `rem` hashsize == 0
-    , piPieceLength >= 0 = return pinfo
-    |       otherwise    = Left undefined
-
-
-putPieceInfo :: PieceInfo -> BDict -> BDict
-putPieceInfo PieceInfo {..} cont =
-       "piece length" .=! piPieceLength
-    .: "pieces"       .=! piPieceHashes
-    .: cont
-
-getPieceInfo :: Get PieceInfo
-getPieceInfo = do
-    PieceInfo <$>! "piece length"
-              <*>! "pieces"
-
-instance BEncode PieceInfo where
-  toBEncode   = toDict . (`putPieceInfo` endDict)
-  fromBEncode = fromDict getPieceInfo
-
--- | Hashes are omitted.
-instance Pretty PieceInfo where
-  pretty  PieceInfo {..} = "Piece size: " <> int piPieceLength
-
-slice :: Int -> Int -> ByteString -> ByteString
-slice start len = BS.take len . BS.drop start
-{-# INLINE slice #-}
-
--- | Extract validation hash by specified piece index.
-pieceHash :: PieceInfo -> PieceIx -> PieceHash
-pieceHash PieceInfo {..} i = slice (hashsize * i) hashsize (unHashList piPieceHashes)
-
--- | Find count of pieces in the torrent. If torrent size is not a
--- multiple of piece size then the count is rounded up.
-pieceCount :: PieceInfo -> PieceCount
-pieceCount PieceInfo {..} = BS.length (unHashList piPieceHashes) `quot` hashsize
-
--- | Test if this is last piece in torrent content.
-isLastPiece :: PieceInfo -> PieceIx -> Bool
-isLastPiece ci i = pieceCount ci == succ i
-
--- | Validate piece with metainfo hash.
-checkPieceLazy :: PieceInfo -> Piece BL.ByteString -> Bool
-checkPieceLazy pinfo @ PieceInfo {..} Piece {..}
-  = (fromIntegral (BL.length pieceData) == piPieceLength
-     || isLastPiece pinfo pieceIndex)
-  && SHA1.hashlazy pieceData == pieceHash pinfo pieceIndex
diff --git a/src/Network/BitTorrent.hs b/src/Network/BitTorrent.hs
index bcc7cfcf..91a58887 100644
--- a/src/Network/BitTorrent.hs
+++ b/src/Network/BitTorrent.hs
@@ -57,7 +57,5 @@ module Network.BitTorrent
        ) where
 
 import Data.Torrent
-import Data.Torrent.InfoHash
-import Data.Torrent.Magnet
 import Network.BitTorrent.Client
 import Network.BitTorrent.Internal.Types
\ No newline at end of file
diff --git a/src/Network/BitTorrent/Address.hs b/src/Network/BitTorrent/Address.hs
new file mode 100644
index 00000000..eeb04c74
--- /dev/null
+++ b/src/Network/BitTorrent/Address.hs
@@ -0,0 +1,1172 @@
+-- |
+--   Module      :  Network.BitTorrent.Address
+--   Copyright   :  (c) Sam Truzjan 2013
+--                  (c) Daniel Gröber 2013
+--   License     :  BSD3
+--   Maintainer  :  pxqr.sta@gmail.com
+--   Stability   :  provisional
+--   Portability :  portable
+--
+--   Peer and Node addresses.
+--
+{-# LANGUAGE FlexibleInstances          #-}
+{-# LANGUAGE RecordWildCards            #-}
+{-# LANGUAGE StandaloneDeriving         #-}
+{-# LANGUAGE ViewPatterns               #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE MultiParamTypeClasses      #-}
+{-# LANGUAGE DeriveDataTypeable         #-}
+{-# LANGUAGE DeriveFunctor              #-}
+{-# LANGUAGE TemplateHaskell            #-}
+{-# OPTIONS -fno-warn-orphans           #-}
+module Network.BitTorrent.Address
+       ( -- * Address
+         Address (..)
+       , fromAddr
+
+         -- ** IP
+       , IPv4
+       , IPv6
+       , IP (..)
+
+         -- * PeerId
+         -- $peer-id
+       , PeerId
+
+         -- ** Generation
+       , genPeerId
+       , timestamp
+       , entropy
+
+         -- ** Encoding
+       , azureusStyle
+       , shadowStyle
+       , defaultClientId
+       , defaultVersionNumber
+
+         -- * PeerAddr
+         -- $peer-addr
+       , PeerAddr(..)
+       , defaultPorts
+       , peerSockAddr
+       , peerSocket
+
+         -- * Node
+         -- ** Id
+       , NodeId
+       , testIdBit
+       , genNodeId
+       , NodeDistance
+       , distance
+
+         -- ** Info
+       , NodeAddr (..)
+       , NodeInfo (..)
+       , rank
+
+         -- * Fingerprint
+         -- $fingerprint
+       , Software (..)
+       , Fingerprint (..)
+       , libFingerprint
+       , fingerprint
+
+         -- * Utils
+       , libUserAgent
+       ) where
+
+import Control.Applicative
+import Control.Monad
+import Data.BEncode as BE
+import Data.BEncode   as BS
+import Data.BEncode.BDict (BKey)
+import Data.Bits
+import Data.ByteString as BS
+import Data.ByteString.Internal as BS
+import Data.ByteString.Base16 as Base16
+import Data.ByteString.Char8 as BC
+import Data.ByteString.Char8 as BS8
+import qualified Data.ByteString.Lazy as BL
+import qualified Data.ByteString.Lazy.Builder as BS
+import Data.Char
+import Data.Convertible
+import Data.Default
+import Data.Foldable
+import Data.IP
+import Data.List as L
+import Data.List.Split as L
+import Data.Maybe       (fromMaybe, catMaybes)
+import Data.Monoid
+import Data.Hashable
+import Data.Ord
+import Data.Serialize as S
+import Data.String
+import Data.Time
+import Data.Typeable
+import Data.Version
+import Data.Word
+import qualified Text.ParserCombinators.ReadP as RP
+import Text.Read        (readMaybe)
+import Network.HTTP.Types.QueryLike
+import Network.Socket
+import Text.PrettyPrint as PP hiding ((<>))
+import Text.PrettyPrint.Class
+import System.Locale    (defaultTimeLocale)
+import System.Entropy
+
+-- import Paths_bittorrent (version)
+
+{-----------------------------------------------------------------------
+--  Address
+-----------------------------------------------------------------------}
+
+instance Pretty UTCTime where
+  pretty = PP.text . show
+
+class (Eq a, Serialize a, Typeable a, Hashable a, Pretty a)
+    => Address a where
+  toSockAddr   :: a        -> SockAddr
+  fromSockAddr :: SockAddr -> Maybe a
+
+fromAddr :: (Address a, Address b) => a -> Maybe b
+fromAddr = fromSockAddr . toSockAddr
+
+-- | Note that port is zeroed.
+instance Address IPv4 where
+  toSockAddr = SockAddrInet 0 . toHostAddress
+  fromSockAddr (SockAddrInet _ h) = Just (fromHostAddress h)
+  fromSockAddr  _                 = Nothing
+
+-- | Note that port is zeroed.
+instance Address IPv6 where
+  toSockAddr h = SockAddrInet6 0 0 (toHostAddress6 h) 0
+  fromSockAddr (SockAddrInet6 _ _ h _) = Just (fromHostAddress6 h)
+  fromSockAddr  _                      = Nothing
+
+-- | Note that port is zeroed.
+instance Address IP where
+  toSockAddr (IPv4 h) = toSockAddr h
+  toSockAddr (IPv6 h) = toSockAddr h
+  fromSockAddr sa =
+        IPv4 <$> fromSockAddr sa
+    <|> IPv6 <$> fromSockAddr sa
+
+setPort :: PortNumber -> SockAddr -> SockAddr
+setPort port (SockAddrInet  _   h  ) = SockAddrInet  port   h
+setPort port (SockAddrInet6 _ f h s) = SockAddrInet6 port f h s
+setPort _    (SockAddrUnix  s      ) = SockAddrUnix  s
+{-# INLINE setPort #-}
+
+getPort :: SockAddr -> Maybe PortNumber
+getPort (SockAddrInet  p   _  ) = Just p
+getPort (SockAddrInet6 p _ _ _) = Just p
+getPort (SockAddrUnix  _      ) = Nothing
+{-# INLINE getPort #-}
+
+instance Address a => Address (NodeAddr a) where
+  toSockAddr NodeAddr {..} = setPort nodePort $ toSockAddr nodeHost
+  fromSockAddr sa = NodeAddr <$> fromSockAddr sa <*> getPort sa
+
+instance Address a => Address (PeerAddr a) where
+  toSockAddr PeerAddr {..} = setPort peerPort $ toSockAddr peerHost
+  fromSockAddr sa = PeerAddr Nothing <$> fromSockAddr sa <*> getPort sa
+
+{-----------------------------------------------------------------------
+--  Peer id
+-----------------------------------------------------------------------}
+-- $peer-id
+--
+--  'PeerID' represent self assigned peer identificator. Ideally each
+--  host in the network should have unique peer id to avoid
+--  collisions, therefore for peer ID generation we use good entropy
+--  source. Peer ID is sent in /tracker request/, sent and received in
+--  /peer handshakes/ and used in DHT queries.
+--
+
+-- TODO use unpacked Word160 form (length is known statically)
+
+-- | Peer identifier is exactly 20 bytes long bytestring.
+newtype PeerId = PeerId { getPeerId :: ByteString }
+  deriving (Show, Eq, Ord, BEncode, Typeable)
+
+peerIdLen :: Int
+peerIdLen = 20
+
+-- | For testing purposes only.
+instance Default PeerId where
+  def = azureusStyle defaultClientId defaultVersionNumber ""
+
+instance Hashable PeerId where
+  hashWithSalt = hashUsing getPeerId
+  {-# INLINE hashWithSalt #-}
+
+instance Serialize PeerId where
+  put = putByteString . getPeerId
+  get = PeerId <$> getBytes peerIdLen
+
+instance QueryValueLike PeerId where
+  toQueryValue (PeerId pid) = Just pid
+  {-# INLINE toQueryValue #-}
+
+instance IsString PeerId where
+  fromString str
+      | BS.length bs == peerIdLen = PeerId bs
+      | otherwise = error $ "Peer id should be 20 bytes long: " ++ show str
+    where
+      bs = fromString str
+
+instance Pretty PeerId where
+  pretty = text . BC.unpack . getPeerId
+
+instance Convertible BS.ByteString PeerId where
+  safeConvert bs
+    | BS.length bs == peerIdLen = pure (PeerId bs)
+    |          otherwise        = convError "invalid length" bs
+
+------------------------------------------------------------------------
+
+-- | Pad bytestring so it's becomes exactly request length. Conversion
+-- is done like so:
+--
+--     * length < size: Complete bytestring by given charaters.
+--
+--     * length = size: Output bytestring as is.
+--
+--     * length > size: Drop last (length - size) charaters from a
+--     given bytestring.
+--
+byteStringPadded :: ByteString -- ^ bytestring to be padded.
+                 -> Int        -- ^ size of result builder.
+                 -> Char       -- ^ character used for padding.
+                 -> BS.Builder
+byteStringPadded bs s c =
+      BS.byteString (BS.take s bs) <>
+      BS.byteString (BC.replicate padLen c)
+  where
+    padLen = s - min (BS.length bs) s
+
+-- | Azureus-style encoding have the following layout:
+--
+--     * 1  byte : '-'
+--
+--     * 2  bytes: client id
+--
+--     * 4  bytes: version number
+--
+--     * 1  byte : '-'
+--
+--     * 12 bytes: random number
+--
+azureusStyle :: ByteString -- ^ 2 character client ID, padded with 'H'.
+             -> ByteString -- ^ Version number, padded with 'X'.
+             -> ByteString -- ^ Random number, padded with '0'.
+             -> PeerId     -- ^ Azureus-style encoded peer ID.
+azureusStyle cid ver rnd = PeerId $ BL.toStrict $ BS.toLazyByteString $
+    BS.char8 '-' <>
+      byteStringPadded cid 2  'H' <>
+      byteStringPadded ver 4  'X' <>
+    BS.char8 '-' <>
+      byteStringPadded rnd 12 '0'
+
+-- | Shadow-style encoding have the following layout:
+--
+--     * 1 byte   : client id.
+--
+--     * 0-4 bytes: version number. If less than 4 then padded with
+--     '-' char.
+--
+--     * 15 bytes : random number. If length is less than 15 then
+--     padded with '0' char.
+--
+shadowStyle :: Char       -- ^ Client ID.
+            -> ByteString -- ^ Version number.
+            -> ByteString -- ^ Random number.
+            -> PeerId     -- ^ Shadow style encoded peer ID.
+shadowStyle cid ver rnd = PeerId $ BL.toStrict $ BS.toLazyByteString $
+    BS.char8 cid <>
+      byteStringPadded ver 4  '-' <>
+      byteStringPadded rnd 15 '0'
+
+
+-- | 'HS'- 2 bytes long client identifier.
+defaultClientId :: ByteString
+defaultClientId = "HS"
+
+-- | Gives exactly 4 bytes long version number for any version of the
+-- package.  Version is taken from .cabal file.
+defaultVersionNumber :: ByteString
+defaultVersionNumber = BS.take 4 $ BC.pack $ foldMap show $
+                         versionBranch myVersion
+  where
+    Fingerprint _ myVersion = libFingerprint
+
+------------------------------------------------------------------------
+
+-- | Gives 15 characters long decimal timestamp such that:
+--
+--     * 6 bytes   : first 6 characters from picoseconds obtained with %q.
+--
+--     * 1 byte    : character \'.\' for readability.
+--
+--     * 9..* bytes: number of whole seconds since the Unix epoch
+--     (!)REVERSED.
+--
+--   Can be used both with shadow and azureus style encoding. This
+--   format is used to make the ID's readable for debugging purposes.
+--
+timestamp :: IO ByteString
+timestamp = (BC.pack . format) <$> getCurrentTime
+  where
+    format t = L.take 6 (formatTime defaultTimeLocale "%q" t) ++ "." ++
+               L.take 9 (L.reverse (formatTime defaultTimeLocale "%s" t))
+
+-- | Gives 15 character long random bytestring. This is more robust
+-- method for generation of random part of peer ID than 'timestamp'.
+entropy :: IO ByteString
+entropy = getEntropy 15
+
+-- NOTE: entropy generates incorrrect peer id
+
+-- |  Here we use 'azureusStyle' encoding with the following args:
+--
+--      * 'HS' for the client id; ('defaultClientId')
+--
+--      * Version of the package for the version number;
+--      ('defaultVersionNumber')
+--
+--      * UTC time day ++ day time for the random number. ('timestamp')
+--
+genPeerId :: IO PeerId
+genPeerId = azureusStyle defaultClientId defaultVersionNumber <$> timestamp
+
+{-----------------------------------------------------------------------
+-- Peer Addr
+-----------------------------------------------------------------------}
+-- $peer-addr
+--
+--   'PeerAddr' is used to represent peer address. Currently it's
+--   just peer IP and peer port but this might change in future.
+--
+
+{-----------------------------------------------------------------------
+--  Port number
+-----------------------------------------------------------------------}
+
+instance BEncode PortNumber where
+  toBEncode   = toBEncode    .  fromEnum
+  fromBEncode = fromBEncode >=> portNumber
+    where
+      portNumber :: Integer -> BS.Result PortNumber
+      portNumber n
+        | 0 <= n && n <= fromIntegral (maxBound :: Word16)
+        = pure $ fromIntegral n
+        | otherwise = decodingError $ "PortNumber: " ++ show n
+
+instance Serialize PortNumber where
+  get = fromIntegral <$> getWord16be
+  {-# INLINE get #-}
+  put = putWord16be . fromIntegral
+  {-# INLINE put #-}
+
+instance Hashable PortNumber where
+  hashWithSalt s = hashWithSalt s . fromEnum
+  {-# INLINE hashWithSalt #-}
+
+instance Pretty PortNumber where
+  pretty = PP.int . fromEnum
+  {-# INLINE pretty #-}
+
+{-----------------------------------------------------------------------
+--  IP addr
+-----------------------------------------------------------------------}
+
+class IPAddress i where
+  toHostAddr :: i -> Either HostAddress HostAddress6
+
+instance IPAddress IPv4 where
+  toHostAddr = Left . toHostAddress
+  {-# INLINE toHostAddr #-}
+
+instance IPAddress IPv6 where
+  toHostAddr = Right . toHostAddress6
+  {-# INLINE toHostAddr #-}
+
+instance IPAddress IP where
+  toHostAddr (IPv4 ip) = toHostAddr ip
+  toHostAddr (IPv6 ip) = toHostAddr ip
+  {-# INLINE toHostAddr #-}
+
+deriving instance Typeable IP
+deriving instance Typeable IPv4
+deriving instance Typeable IPv6
+
+ipToBEncode :: Show i => i -> BValue
+ipToBEncode ip = BString $ BS8.pack $ show ip
+{-# INLINE ipToBEncode #-}
+
+ipFromBEncode :: Read a => BValue -> BS.Result a
+ipFromBEncode (BString (BS8.unpack -> ipStr))
+  | Just ip <- readMaybe (ipStr) = pure ip
+  |         otherwise            = decodingError $ "IP: " ++ ipStr
+ipFromBEncode _    = decodingError $ "IP: addr should be a bstring"
+
+instance BEncode IP where
+  toBEncode   = ipToBEncode
+  {-# INLINE toBEncode #-}
+  fromBEncode = ipFromBEncode
+  {-# INLINE fromBEncode #-}
+
+instance BEncode IPv4 where
+  toBEncode   = ipToBEncode
+  {-# INLINE toBEncode #-}
+  fromBEncode = ipFromBEncode
+  {-# INLINE fromBEncode #-}
+
+instance BEncode IPv6 where
+  toBEncode   = ipToBEncode
+  {-# INLINE toBEncode #-}
+  fromBEncode = ipFromBEncode
+  {-# INLINE fromBEncode #-}
+
+-- | When 'get'ing an IP it must be 'isolate'd to the appropriate
+-- number of bytes since we have no other way of telling which
+-- address type we are trying to parse
+instance Serialize IP where
+    put (IPv4 ip) = put ip
+    put (IPv6 ip) = put ip
+
+    get = do
+      n <- remaining
+      case n of
+        4  -> IPv4 <$> get
+        16 -> IPv6 <$> get
+        _ -> fail "Wrong number of bytes remaining to parse IP"
+
+instance Serialize IPv4 where
+    put = putWord32host    .  toHostAddress
+    get = fromHostAddress <$> getWord32host
+
+instance Serialize IPv6 where
+    put ip = put $ toHostAddress6 ip
+    get = fromHostAddress6 <$> get
+
+instance Pretty IPv4 where
+  pretty = PP.text . show
+  {-# INLINE pretty #-}
+
+instance Pretty IPv6 where
+  pretty = PP.text . show
+  {-# INLINE pretty #-}
+
+instance Pretty IP where
+  pretty = PP.text . show
+  {-# INLINE pretty #-}
+
+instance Hashable IPv4 where
+  hashWithSalt = hashUsing toHostAddress
+  {-# INLINE hashWithSalt #-}
+
+instance Hashable IPv6 where
+  hashWithSalt s a = hashWithSalt s (toHostAddress6 a)
+
+instance Hashable IP where
+  hashWithSalt s (IPv4 h) = hashWithSalt s h
+  hashWithSalt s (IPv6 h) = hashWithSalt s h
+
+{-----------------------------------------------------------------------
+--  Peer addr
+-----------------------------------------------------------------------}
+-- TODO check semantic of ord and eq instances
+
+-- | Peer address info normally extracted from peer list or peer
+-- compact list encoding.
+data PeerAddr a = PeerAddr
+  { peerId   :: !(Maybe PeerId)
+
+    -- | This is usually 'IPv4', 'IPv6', 'IP' or unresolved
+    -- 'HostName'.
+  , peerHost :: !a
+
+    -- | The port the peer listenning for incoming P2P sessions.
+  , peerPort :: {-# UNPACK #-} !PortNumber
+  } deriving (Show, Eq, Ord, Typeable, Functor)
+
+peer_ip_key, peer_id_key, peer_port_key :: BKey
+peer_ip_key   = "ip"
+peer_id_key   = "peer id"
+peer_port_key = "port"
+
+-- | The tracker's 'announce response' compatible encoding.
+instance (Typeable a, BEncode a) => BEncode (PeerAddr a) where
+  toBEncode PeerAddr {..} = toDict $
+       peer_ip_key   .=! peerHost
+    .: peer_id_key   .=? peerId
+    .: peer_port_key .=! peerPort
+    .: endDict
+
+  fromBEncode = fromDict $ do
+    peerAddr <$>! peer_ip_key
+             <*>? peer_id_key
+             <*>! peer_port_key
+    where
+      peerAddr = flip PeerAddr
+
+-- | The tracker's 'compact peer list' compatible encoding. The
+-- 'peerId' is always 'Nothing'.
+--
+--   For more info see: <http://www.bittorrent.org/beps/bep_0023.html>
+--
+-- TODO: test byte order
+instance (Serialize a) => Serialize (PeerAddr a) where
+  put PeerAddr {..} = put peerHost >> put peerPort
+  get = PeerAddr Nothing <$> get <*> get
+
+-- | @127.0.0.1:6881@
+instance Default (PeerAddr IPv4) where
+  def = "127.0.0.1:6881"
+
+-- | @127.0.0.1:6881@
+instance Default (PeerAddr IP) where
+  def = IPv4 <$> def
+
+-- | Example:
+--
+--   @peerPort \"127.0.0.1:6881\" == 6881@
+--
+instance IsString (PeerAddr IPv4) where
+  fromString str
+    | [hostAddrStr, portStr] <- splitWhen (== ':') str
+    , Just hostAddr <- readMaybe hostAddrStr
+    , Just portNum  <- toEnum <$> readMaybe portStr
+                = PeerAddr Nothing hostAddr portNum
+    | otherwise = error $ "fromString: unable to parse (PeerAddr IPv4): " ++ str
+
+instance Read (PeerAddr IPv4) where
+  readsPrec i = RP.readP_to_S $ do
+    ipv4 <- RP.readS_to_P (readsPrec i)
+    _    <- RP.char ':'
+    port <- toEnum <$> RP.readS_to_P (readsPrec i)
+    return $ PeerAddr Nothing ipv4 port
+
+readsIPv6_port :: String -> [((IPv6, PortNumber), String)]
+readsIPv6_port = RP.readP_to_S $ do
+  ip <- RP.char '[' *> (RP.readS_to_P reads) <* RP.char ']'
+  _ <- RP.char ':'
+  port <- toEnum <$> read <$> (RP.many1 $ RP.satisfy isDigit) <* RP.eof
+  return (ip,port)
+
+instance IsString (PeerAddr IPv6) where
+  fromString str
+    | [((ip,port),"")] <- readsIPv6_port str =
+        PeerAddr Nothing ip port
+    | otherwise = error $ "fromString: unable to parse (PeerAddr IPv6): " ++ str
+
+instance IsString (PeerAddr IP) where
+  fromString str
+    | '[' `L.elem` str = IPv6 <$> fromString str
+    |      otherwise   = IPv4 <$> fromString str
+
+-- | fingerprint + "at" + dotted.host.inet.addr:port
+-- TODO: instances for IPv6, HostName
+instance Pretty a => Pretty (PeerAddr a) where
+  pretty PeerAddr {..}
+    | Just pid <- peerId = pretty (fingerprint pid) <+> "at" <+> paddr
+    |     otherwise      = paddr
+    where
+      paddr = pretty peerHost <> ":" <> text (show peerPort)
+
+instance Hashable a => Hashable (PeerAddr a) where
+  hashWithSalt s PeerAddr {..} =
+    s `hashWithSalt` peerId `hashWithSalt` peerHost `hashWithSalt` peerPort
+
+-- | Ports typically reserved for bittorrent P2P listener.
+defaultPorts :: [PortNumber]
+defaultPorts =  [6881..6889]
+
+_resolvePeerAddr :: (IPAddress i) => PeerAddr HostName -> PeerAddr i
+_resolvePeerAddr = undefined
+
+_peerSockAddr :: PeerAddr IP -> (Family, SockAddr)
+_peerSockAddr PeerAddr {..} =
+    case peerHost of
+          IPv4 ipv4 ->
+              (AF_INET, SockAddrInet peerPort (toHostAddress  ipv4))
+          IPv6 ipv6 ->
+              (AF_INET6, SockAddrInet6 peerPort 0 (toHostAddress6 ipv6) 0)
+
+peerSockAddr :: PeerAddr IP -> SockAddr
+peerSockAddr = snd . _peerSockAddr
+
+-- | Create a socket connected to the address specified in a peerAddr
+peerSocket :: SocketType -> PeerAddr IP -> IO Socket
+peerSocket socketType pa = do
+    let (family, addr) = _peerSockAddr pa
+    sock <- socket family socketType defaultProtocol
+    connect sock addr
+    return sock
+
+{-----------------------------------------------------------------------
+--  Node info
+-----------------------------------------------------------------------}
+--   $node-info
+--
+--   A \"node\" is a client\/server listening on a UDP port
+--   implementing the distributed hash table protocol. The DHT is
+--   composed of nodes and stores the location of peers. BitTorrent
+--   clients include a DHT node, which is used to contact other nodes
+--   in the DHT to get the location of peers to download from using
+--   the BitTorrent protocol.
+
+-- TODO more compact representation ('ShortByteString's?)
+
+-- | Each node has a globally unique identifier known as the \"node
+-- ID.\"
+--
+--   Normally, /this/ node id should be saved between invocations
+--   of the client software.
+newtype NodeId = NodeId ByteString
+  deriving (Show, Eq, Ord, BEncode, Typeable)
+
+nodeIdSize :: Int
+nodeIdSize = 20
+
+-- | Meaningless node id, for testing purposes only.
+instance Default NodeId where
+  def = NodeId (BS.replicate nodeIdSize 0)
+
+instance Serialize NodeId where
+  get = NodeId <$> getByteString nodeIdSize
+  {-# INLINE get #-}
+  put (NodeId bs) = putByteString bs
+  {-# INLINE put #-}
+
+-- | ASCII encoded.
+instance IsString NodeId where
+  fromString str
+    | L.length str == nodeIdSize = NodeId (fromString str)
+    |           otherwise = error "fromString: invalid NodeId length"
+  {-# INLINE fromString #-}
+
+-- | base16 encoded.
+instance Pretty NodeId where
+  pretty (NodeId nid) = PP.text $ BC.unpack $ Base16.encode nid
+
+-- | Test if the nth bit is set.
+testIdBit :: NodeId -> Word -> Bool
+testIdBit (NodeId bs) i
+  | fromIntegral i < nodeIdSize * 8
+  , (q, r) <- quotRem (fromIntegral i) 8
+  = testBit (BS.index bs q) r
+  |     otherwise      = False
+{-# INLINE testIdBit #-}
+
+-- TODO WARN is the 'system' random suitable for this?
+-- | Generate random NodeID used for the entire session.
+--   Distribution of ID's should be as uniform as possible.
+--
+genNodeId :: IO NodeId
+genNodeId = NodeId <$> getEntropy nodeIdSize
+
+------------------------------------------------------------------------
+
+-- | In Kademlia, the distance metric is XOR and the result is
+-- interpreted as an unsigned integer.
+newtype NodeDistance = NodeDistance BS.ByteString
+  deriving (Eq, Ord)
+
+instance Pretty NodeDistance where
+  pretty (NodeDistance bs) = foldMap bitseq $ BS.unpack bs
+    where
+      listBits w = L.map (testBit w) (L.reverse [0..bitSize w - 1])
+      bitseq = foldMap (int . fromEnum) . listBits
+
+-- | distance(A,B) = |A xor B| Smaller values are closer.
+distance :: NodeId -> NodeId -> NodeDistance
+distance (NodeId a) (NodeId b) = NodeDistance (BS.pack (BS.zipWith xor a b))
+
+------------------------------------------------------------------------
+
+data NodeAddr a = NodeAddr
+  { nodeHost ::                !a
+  , nodePort :: {-# UNPACK #-} !PortNumber
+  } deriving (Eq, Typeable, Functor)
+
+instance Show a => Show (NodeAddr a) where
+  showsPrec i NodeAddr {..}
+    = showsPrec i nodeHost <> showString ":" <> showsPrec i nodePort
+
+instance Read (NodeAddr IPv4) where
+  readsPrec i x = [ (fromPeerAddr a, s) | (a, s) <- readsPrec i x ]
+
+-- | @127.0.0.1:6882@
+instance Default (NodeAddr IPv4) where
+  def = "127.0.0.1:6882"
+
+-- | KRPC compatible encoding.
+instance Serialize a => Serialize (NodeAddr a) where
+  get = NodeAddr <$> get <*> get
+  {-# INLINE get #-}
+  put NodeAddr {..} = put nodeHost >> put nodePort
+  {-# INLINE put #-}
+
+-- | Torrent file compatible encoding.
+instance BEncode a => BEncode (NodeAddr a) where
+  toBEncode NodeAddr {..} = toBEncode (nodeHost, nodePort)
+  {-# INLINE toBEncode #-}
+  fromBEncode b = uncurry NodeAddr <$> fromBEncode b
+  {-# INLINE fromBEncode #-}
+
+instance Hashable a => Hashable (NodeAddr a) where
+  hashWithSalt s NodeAddr {..} = hashWithSalt s (nodeHost, nodePort)
+  {-# INLINE hashWithSalt #-}
+
+instance Pretty ip => Pretty (NodeAddr ip) where
+  pretty NodeAddr {..} = pretty nodeHost <> ":" <> pretty nodePort
+
+-- | Example:
+--
+--   @nodePort \"127.0.0.1:6881\" == 6881@
+--
+instance IsString (NodeAddr IPv4) where
+  fromString = fromPeerAddr . fromString
+
+fromPeerAddr :: PeerAddr a -> NodeAddr a
+fromPeerAddr PeerAddr {..} = NodeAddr
+  { nodeHost = peerHost
+  , nodePort = peerPort
+  }
+
+------------------------------------------------------------------------
+
+data NodeInfo a = NodeInfo
+  { nodeId   :: !NodeId
+  , nodeAddr :: !(NodeAddr a)
+  } deriving (Show, Eq, Functor)
+
+instance Eq a => Ord (NodeInfo a) where
+  compare = comparing nodeId
+
+-- | KRPC 'compact list' compatible encoding: contact information for
+-- nodes is encoded as a 26-byte string. Also known as "Compact node
+-- info" the 20-byte Node ID in network byte order has the compact
+-- IP-address/port info concatenated to the end.
+instance Serialize a => Serialize (NodeInfo a) where
+  get = NodeInfo <$> get <*> get
+  put NodeInfo {..} = put nodeId >> put nodeAddr
+
+instance Pretty ip => Pretty (NodeInfo ip) where
+  pretty NodeInfo {..} = pretty nodeId <> "@(" <> pretty nodeAddr <> ")"
+
+instance Pretty ip => Pretty [NodeInfo ip] where
+  pretty = PP.vcat . PP.punctuate "," . L.map pretty
+
+-- | Order by closeness: nearest nodes first.
+rank :: Eq ip => NodeId -> [NodeInfo ip] -> [NodeInfo ip]
+rank nid = L.sortBy (comparing (distance nid . nodeId))
+
+{-----------------------------------------------------------------------
+-- Fingerprint
+-----------------------------------------------------------------------}
+-- $fingerprint
+--
+--   'Fingerprint' is used to identify the client implementation and
+--   version which also contained in 'Peer'. For exsample first 6
+--   bytes of peer id of this this library are @-HS0100-@ while for
+--   mainline we have @M4-3-6--@.  We could extract this info and
+--   print in human-friendly form: this is useful for debugging and
+--   logging.
+--
+--   For more information see:
+--   <http://bittorrent.org/beps/bep_0020.html>
+--
+--
+--   NOTE: Do /not/ use this information to control client
+--   capabilities (such as supported enchancements), this should be
+--   done using 'Network.BitTorrent.Extension'!
+--
+
+-- TODO FIXME
+version :: Version
+version = Version [0, 0, 0, 3] []
+
+-- | List of registered client versions + 'IlibHSbittorrent' (this
+-- package) + 'IUnknown' (for not recognized software). All names are
+-- prefixed by \"I\" because some of them starts from lowercase letter
+-- but that is not a valid Haskell constructor name.
+--
+data Software =
+   IUnknown
+
+ | IMainline
+
+ | IABC
+ | IOspreyPermaseed
+ | IBTQueue
+ | ITribler
+ | IShadow
+ | IBitTornado
+
+-- UPnP(!) Bit Torrent !???
+-- 'U' - UPnP NAT Bit Torrent
+ | IBitLord
+ | IOpera
+ | IMLdonkey
+
+ | IAres
+ | IArctic
+ | IAvicora
+ | IBitPump
+ | IAzureus
+ | IBitBuddy
+ | IBitComet
+ | IBitflu
+ | IBTG
+ | IBitRocket
+ | IBTSlave
+ | IBittorrentX
+ | IEnhancedCTorrent
+ | ICTorrent
+ | IDelugeTorrent
+ | IPropagateDataClient
+ | IEBit
+ | IElectricSheep
+ | IFoxTorrent
+ | IGSTorrent
+ | IHalite
+ | IlibHSbittorrent
+ | IHydranode
+ | IKGet
+ | IKTorrent
+ | ILH_ABC
+ | ILphant
+ | ILibtorrent
+ | ILibTorrent
+ | ILimeWire
+ | IMonoTorrent
+ | IMooPolice
+ | IMiro
+ | IMoonlightTorrent
+ | INetTransport
+ | IPando
+ | IqBittorrent
+ | IQQDownload
+ | IQt4TorrentExample
+ | IRetriever
+ | IShareaza
+ | ISwiftbit
+ | ISwarmScope
+ | ISymTorrent
+ | Isharktorrent
+ | ITorrentDotNET
+ | ITransmission
+ | ITorrentstorm
+ | ITuoTu
+ | IuLeecher
+ | IuTorrent
+ | IVagaa
+ | IBitLet
+ | IFireTorrent
+ | IXunlei
+ | IXanTorrent
+ | IXtorrent
+ | IZipTorrent
+   deriving (Show, Eq, Ord, Enum, Bounded)
+
+parseSoftware :: ByteString -> Software
+parseSoftware = f . BC.unpack
+ where
+  f "AG" = IAres
+  f "A~" = IAres
+  f "AR" = IArctic
+  f "AV" = IAvicora
+  f "AX" = IBitPump
+  f "AZ" = IAzureus
+  f "BB" = IBitBuddy
+  f "BC" = IBitComet
+  f "BF" = IBitflu
+  f "BG" = IBTG
+  f "BR" = IBitRocket
+  f "BS" = IBTSlave
+  f "BX" = IBittorrentX
+  f "CD" = IEnhancedCTorrent
+  f "CT" = ICTorrent
+  f "DE" = IDelugeTorrent
+  f "DP" = IPropagateDataClient
+  f "EB" = IEBit
+  f "ES" = IElectricSheep
+  f "FT" = IFoxTorrent
+  f "GS" = IGSTorrent
+  f "HL" = IHalite
+  f "HS" = IlibHSbittorrent
+  f "HN" = IHydranode
+  f "KG" = IKGet
+  f "KT" = IKTorrent
+  f "LH" = ILH_ABC
+  f "LP" = ILphant
+  f "LT" = ILibtorrent
+  f "lt" = ILibTorrent
+  f "LW" = ILimeWire
+  f "MO" = IMonoTorrent
+  f "MP" = IMooPolice
+  f "MR" = IMiro
+  f "ML" = IMLdonkey
+  f "MT" = IMoonlightTorrent
+  f "NX" = INetTransport
+  f "PD" = IPando
+  f "qB" = IqBittorrent
+  f "QD" = IQQDownload
+  f "QT" = IQt4TorrentExample
+  f "RT" = IRetriever
+  f "S~" = IShareaza
+  f "SB" = ISwiftbit
+  f "SS" = ISwarmScope
+  f "ST" = ISymTorrent
+  f "st" = Isharktorrent
+  f "SZ" = IShareaza
+  f "TN" = ITorrentDotNET
+  f "TR" = ITransmission
+  f "TS" = ITorrentstorm
+  f "TT" = ITuoTu
+  f "UL" = IuLeecher
+  f "UT" = IuTorrent
+  f "VG" = IVagaa
+  f "WT" = IBitLet
+  f "WY" = IFireTorrent
+  f "XL" = IXunlei
+  f "XT" = IXanTorrent
+  f "XX" = IXtorrent
+  f "ZT" = IZipTorrent
+  f _    = IUnknown
+
+-- | Used to represent a not recognized implementation
+instance Default Software where
+  def = IUnknown
+  {-# INLINE def #-}
+
+-- | Example: @\"BitLet\" == 'IBitLet'@
+instance IsString Software where
+  fromString str
+    | Just impl <- L.lookup str alist = impl
+    | otherwise = error $ "fromString: not recognized " ++ str
+    where
+      alist = L.map mk [minBound..maxBound]
+      mk  x = (L.tail $ show x, x)
+
+-- | Example: @pretty 'IBitLet' == \"IBitLet\"@
+instance Pretty Software where
+  pretty = text . L.tail . show
+
+-- | Just the '0' version.
+instance Default Version where
+  def = Version [0] []
+  {-# INLINE def #-}
+
+-- | For dot delimited version strings.
+--   Example: @fromString \"0.1.0.2\" == Version [0, 1, 0, 2]@
+--
+instance IsString Version where
+  fromString str
+    | Just nums <- chunkNums str = Version nums []
+    | otherwise = error $ "fromString: invalid version string " ++ str
+    where
+      chunkNums = sequence . L.map readMaybe . L.linesBy ('.' ==)
+
+instance Pretty Version where
+  pretty = text . showVersion
+
+-- | The all sensible infomation that can be obtained from a peer
+-- identifier or torrent /createdBy/ field.
+data Fingerprint = Fingerprint Software Version
+  deriving (Show, Eq, Ord)
+
+-- | Unrecognized client implementation.
+instance Default Fingerprint where
+  def = Fingerprint def def
+  {-# INLINE def #-}
+
+-- | Example: @\"BitComet-1.2\" == ClientInfo IBitComet (Version [1, 2] [])@
+instance IsString Fingerprint where
+  fromString str
+    | _ : ver <- _ver = Fingerprint (fromString impl) (fromString ver)
+    | otherwise = error $ "fromString: invalid client info string" ++ str
+    where
+      (impl, _ver) = L.span ((/=) '-') str
+
+instance Pretty Fingerprint where
+  pretty (Fingerprint s v) = pretty s <+> "version" <+> pretty v
+
+-- | Fingerprint of this (the bittorrent library) package. Normally,
+-- applications should introduce its own fingerprints, otherwise they
+-- can use 'libFingerprint' value.
+--
+libFingerprint :: Fingerprint
+libFingerprint =  Fingerprint IlibHSbittorrent version
+
+-- | HTTP user agent of this (the bittorrent library) package. Can be
+-- used in HTTP tracker requests.
+libUserAgent :: String
+libUserAgent = render (pretty IlibHSbittorrent <> "/" <> pretty version)
+
+{-----------------------------------------------------------------------
+--  For torrent file
+-----------------------------------------------------------------------}
+-- TODO collect information about createdBy torrent field
+{-
+renderImpl :: ClientImpl -> Text
+renderImpl = T.pack . L.tail . show
+
+renderVersion :: Version -> Text
+renderVersion = undefined
+
+renderClientInfo :: ClientInfo -> Text
+renderClientInfo ClientInfo {..} = renderImpl ciImpl <> "/" <> renderVersion ciVersion
+
+parseClientInfo :: Text -> ClientImpl
+parseClientInfo t = undefined
+-}
+{-
+-- code used for generation; remove it later on
+
+mkEnumTyDef :: NM -> String
+mkEnumTyDef = unlines . map (" | I" ++) . nub . map snd
+
+mkPars :: NM -> String
+mkPars = unlines . map (\(code, impl) -> "  f \"" ++ code ++ "\" = " ++ "I" ++ impl)
+
+type NM = [(String, String)]
+nameMap :: NM
+nameMap =
+ [ ("AG", "Ares")
+ , ("A~", "Ares")
+ , ("AR", "Arctic")
+ , ("AV", "Avicora")
+ , ("AX", "BitPump")
+ , ("AZ", "Azureus")
+ , ("BB", "BitBuddy")
+ , ("BC", "BitComet")
+ , ("BF", "Bitflu")
+ , ("BG", "BTG")
+ , ("BR", "BitRocket")
+ , ("BS", "BTSlave")
+ , ("BX", "BittorrentX")
+ , ("CD", "EnhancedCTorrent")
+ , ("CT", "CTorrent")
+ , ("DE", "DelugeTorrent")
+ , ("DP", "PropagateDataClient")
+ , ("EB", "EBit")
+ , ("ES", "ElectricSheep")
+ , ("FT", "FoxTorrent")
+ , ("GS", "GSTorrent")
+ , ("HL", "Halite")
+ , ("HS", "libHSnetwork_bittorrent")
+ , ("HN", "Hydranode")
+ , ("KG", "KGet")
+ , ("KT", "KTorrent")
+ , ("LH", "LH_ABC")
+ , ("LP", "Lphant")
+ , ("LT", "Libtorrent")
+ , ("lt", "LibTorrent")
+ , ("LW", "LimeWire")
+ , ("MO", "MonoTorrent")
+ , ("MP", "MooPolice")
+ , ("MR", "Miro")
+ , ("MT", "MoonlightTorrent")
+ , ("NX", "NetTransport")
+ , ("PD", "Pando")
+ , ("qB", "qBittorrent")
+ , ("QD", "QQDownload")
+ , ("QT", "Qt4TorrentExample")
+ , ("RT", "Retriever")
+ , ("S~", "Shareaza")
+ , ("SB", "Swiftbit")
+ , ("SS", "SwarmScope")
+ , ("ST", "SymTorrent")
+ , ("st", "sharktorrent")
+ , ("SZ", "Shareaza")
+ , ("TN", "TorrentDotNET")
+ , ("TR", "Transmission")
+ , ("TS", "Torrentstorm")
+ , ("TT", "TuoTu")
+ , ("UL", "uLeecher")
+ , ("UT", "uTorrent")
+ , ("VG", "Vagaa")
+ , ("WT", "BitLet")
+ , ("WY", "FireTorrent")
+ , ("XL", "Xunlei")
+ , ("XT", "XanTorrent")
+ , ("XX", "Xtorrent")
+ , ("ZT", "ZipTorrent")
+ ]
+-}
+
+-- TODO use regexps
+
+-- | Tries to extract meaningful information from peer ID bytes. If
+-- peer id uses unknown coding style then client info returned is
+-- 'def'.
+--
+fingerprint :: PeerId -> Fingerprint
+fingerprint pid = either (const def) id $ runGet getCI (getPeerId pid)
+  where
+    getCI    = do
+      leading <- BS.w2c <$> getWord8
+      case leading of
+        '-' -> Fingerprint <$> getAzureusImpl <*> getAzureusVersion
+        'M' -> Fingerprint <$> pure IMainline <*> getMainlineVersion
+        'e' -> Fingerprint <$> getBitCometImpl <*> getBitCometVersion
+        'F' -> Fingerprint <$> getBitCometImpl <*> getBitCometVersion
+        c   -> do
+          c1 <- w2c <$> S.lookAhead getWord8
+          if c1 == 'P'
+            then do
+                 _ <- getWord8
+                 Fingerprint <$> pure IOpera            <*> getOperaVersion
+            else Fingerprint <$> pure (getShadowImpl c) <*> getShadowVersion
+
+    getMainlineVersion = do
+      str <- BC.unpack <$> getByteString 7
+      let mnums = L.filter (not . L.null) $ L.linesBy ('-' ==) str
+      return $ Version (fromMaybe [] $ sequence $ L.map readMaybe mnums) []
+
+    getAzureusImpl    = parseSoftware <$> getByteString 2
+    getAzureusVersion = mkVer         <$> getByteString 4
+      where
+        mkVer bs = Version [fromMaybe 0 $ readMaybe $ BC.unpack bs] []
+
+    getBitCometImpl = do
+      bs <- getByteString 3
+      S.lookAhead $ do
+        _  <- getByteString 2
+        lr <- getByteString 4
+        return $
+          if lr == "LORD" then IBitLord  else
+          if bs == "UTB"  then IBitComet else
+          if bs == "xbc"  then IBitComet else def
+
+    getBitCometVersion = do
+      x <- getWord8
+      y <- getWord8
+      return $ Version [fromIntegral x, fromIntegral y] []
+
+    getOperaVersion = do
+      str <- BC.unpack <$> getByteString 4
+      return $ Version [fromMaybe 0 $ readMaybe str] []
+
+    getShadowImpl 'A' = IABC
+    getShadowImpl 'O' = IOspreyPermaseed
+    getShadowImpl 'Q' = IBTQueue
+    getShadowImpl 'R' = ITribler
+    getShadowImpl 'S' = IShadow
+    getShadowImpl 'T' = IBitTornado
+    getShadowImpl  _  = IUnknown
+
+    decodeShadowVerNr :: Char -> Maybe Int
+    decodeShadowVerNr c
+      | '0' < c && c <= '9' = Just  (fromEnum c - fromEnum '0')
+      | 'A' < c && c <= 'Z' = Just ((fromEnum c - fromEnum 'A') + 10)
+      | 'a' < c && c <= 'z' = Just ((fromEnum c - fromEnum 'a') + 36)
+      |        otherwise    = Nothing
+
+    getShadowVersion = do
+      str <- BC.unpack <$> getByteString 5
+      return $ Version (catMaybes $ L.map decodeShadowVerNr str) []
diff --git a/src/Network/BitTorrent/Client.hs b/src/Network/BitTorrent/Client.hs
index bf6740c3..d21b4d1e 100644
--- a/src/Network/BitTorrent/Client.hs
+++ b/src/Network/BitTorrent/Client.hs
@@ -61,11 +61,9 @@ import Data.Text
 import Network
 
 import           Data.Torrent
-import           Data.Torrent.InfoHash
-import           Data.Torrent.Magnet
+import           Network.BitTorrent.Address
 import           Network.BitTorrent.Client.Types
 import           Network.BitTorrent.Client.Handle
-import           Network.BitTorrent.Core
 import           Network.BitTorrent.DHT      as DHT      hiding (Options)
 import           Network.BitTorrent.Tracker  as Tracker  hiding (Options)
 import           Network.BitTorrent.Exchange as Exchange hiding (Options)
diff --git a/src/Network/BitTorrent/Client/Handle.hs b/src/Network/BitTorrent/Client/Handle.hs
index 0d1b7f92..66baac48 100644
--- a/src/Network/BitTorrent/Client/Handle.hs
+++ b/src/Network/BitTorrent/Client/Handle.hs
@@ -26,8 +26,6 @@ import Data.List as L
 import Data.HashMap.Strict as HM
 
 import Data.Torrent
-import Data.Torrent.InfoHash
-import Data.Torrent.Magnet
 import Network.BitTorrent.Client.Types as Types
 import Network.BitTorrent.DHT      as DHT
 import Network.BitTorrent.Exchange as Exchange
diff --git a/src/Network/BitTorrent/Client/Types.hs b/src/Network/BitTorrent/Client/Types.hs
index c019bc5f..9bae7dc3 100644
--- a/src/Network/BitTorrent/Client/Types.hs
+++ b/src/Network/BitTorrent/Client/Types.hs
@@ -34,9 +34,9 @@ import Data.Ord
 import Network
 import System.Log.FastLogger
 
-import Data.Torrent.InfoHash
+import Data.Torrent
+import Network.BitTorrent.Address
 import Network.BitTorrent.Internal.Types as Types
-import Network.BitTorrent.Core
 import Network.BitTorrent.DHT      as DHT
 import Network.BitTorrent.Exchange as Exchange
 import Network.BitTorrent.Tracker  as Tracker hiding (Event)
@@ -100,7 +100,7 @@ externalAddr Client {..} = PeerAddr
 newtype BitTorrent a = BitTorrent
   { unBitTorrent :: ReaderT Client IO a
   } deriving ( Functor, Applicative, Monad
-             , MonadIO, MonadThrow, MonadUnsafeIO, MonadBase IO
+             , MonadIO, MonadThrow, MonadBase IO
              )
 
 class MonadBitTorrent m where
diff --git a/src/Network/BitTorrent/Core.hs b/src/Network/BitTorrent/Core.hs
deleted file mode 100644
index b9b3c065..00000000
--- a/src/Network/BitTorrent/Core.hs
+++ /dev/null
@@ -1,88 +0,0 @@
--- |
---   Copyright   :  (c) Sam Truzjan 2013
---   License     :  BSD3
---   Maintainer  :  pxqr.sta@gmail.com
---   Stability   :  experimental
---   Portability :  portable
---
---   Re-export every @Network.BitTorrent.Core.*@ module.
---
-module Network.BitTorrent.Core
-       ( module Core
-
-         -- * Address class
-       , Address (..)
-       , fromAddr
-
-         -- * Re-exports from Data.IP
-       , IPv4
-       , IPv6
-       , IP (..)
-       ) where
-
-import Control.Applicative
-import Data.IP
-import Data.Hashable
-import Data.Serialize
-import Data.Time
-import Data.Typeable
-import Network.Socket (SockAddr (..), PortNumber)
-import Text.PrettyPrint as PP hiding ((<>))
-import Text.PrettyPrint.Class
-
-import Network.BitTorrent.Core.Fingerprint as Core
-import Network.BitTorrent.Core.NodeInfo    as Core
-import Network.BitTorrent.Core.PeerId      as Core
-import Network.BitTorrent.Core.PeerAddr    as Core
-
-
-instance Pretty UTCTime where
-  pretty = PP.text . show
-
-class (Eq a, Serialize a, Typeable a, Hashable a, Pretty a)
-    => Address a where
-  toSockAddr   :: a        -> SockAddr
-  fromSockAddr :: SockAddr -> Maybe a
-
-fromAddr :: (Address a, Address b) => a -> Maybe b
-fromAddr = fromSockAddr . toSockAddr
-
--- | Note that port is zeroed.
-instance Address IPv4 where
-  toSockAddr = SockAddrInet 0 . toHostAddress
-  fromSockAddr (SockAddrInet _ h) = Just (fromHostAddress h)
-  fromSockAddr  _                 = Nothing
-
--- | Note that port is zeroed.
-instance Address IPv6 where
-  toSockAddr h = SockAddrInet6 0 0 (toHostAddress6 h) 0
-  fromSockAddr (SockAddrInet6 _ _ h _) = Just (fromHostAddress6 h)
-  fromSockAddr  _                      = Nothing
-
--- | Note that port is zeroed.
-instance Address IP where
-  toSockAddr (IPv4 h) = toSockAddr h
-  toSockAddr (IPv6 h) = toSockAddr h
-  fromSockAddr sa =
-        IPv4 <$> fromSockAddr sa
-    <|> IPv6 <$> fromSockAddr sa
-
-setPort :: PortNumber -> SockAddr -> SockAddr
-setPort port (SockAddrInet  _   h  ) = SockAddrInet  port   h
-setPort port (SockAddrInet6 _ f h s) = SockAddrInet6 port f h s
-setPort _    (SockAddrUnix  s      ) = SockAddrUnix  s
-{-# INLINE setPort #-}
-
-getPort :: SockAddr -> Maybe PortNumber
-getPort (SockAddrInet  p   _  ) = Just p
-getPort (SockAddrInet6 p _ _ _) = Just p
-getPort (SockAddrUnix  _      ) = Nothing
-{-# INLINE getPort #-}
-
-instance Address a => Address (NodeAddr a) where
-  toSockAddr NodeAddr {..} = setPort nodePort $ toSockAddr nodeHost
-  fromSockAddr sa = NodeAddr <$> fromSockAddr sa <*> getPort sa
-
-instance Address a => Address (PeerAddr a) where
-  toSockAddr PeerAddr {..} = setPort peerPort $ toSockAddr peerHost
-  fromSockAddr sa = PeerAddr Nothing <$> fromSockAddr sa <*> getPort sa
diff --git a/src/Network/BitTorrent/Core/Fingerprint.hs b/src/Network/BitTorrent/Core/Fingerprint.hs
deleted file mode 100644
index d743acd0..00000000
--- a/src/Network/BitTorrent/Core/Fingerprint.hs
+++ /dev/null
@@ -1,290 +0,0 @@
--- |
---   Copyright   :  (c) Sam Truzjan 2013
---   License     :  BSD3
---   Maintainer  :  pxqr.sta@gmail.com
---   Stability   :  experimental
---   Portability :  portable
---
---   'Fingerprint' is used to identify the client implementation and
---   version which also contained in 'Peer'. For exsample first 6
---   bytes of peer id of this this library are @-HS0100-@ while for
---   mainline we have @M4-3-6--@.  We could extract this info and
---   print in human-friendly form: this is useful for debugging and
---   logging.
---
---   For more information see:
---   <http://bittorrent.org/beps/bep_0020.html>
---
---
---   NOTE: Do /not/ use this information to control client
---   capabilities (such as supported enchancements), this should be
---   done using 'Network.BitTorrent.Extension'!
---
-{-# OPTIONS -fno-warn-orphans #-}
-module Network.BitTorrent.Core.Fingerprint
-       ( ClientImpl (..)
-       , Fingerprint (..)
-       , libFingerprint
-       , libUserAgent
-       ) where
-
-import Data.Default
-import Data.List as L
-import Data.List.Split as L
-import Data.Monoid
-import Data.String
-import Data.Version
-import Text.PrettyPrint hiding ((<>))
-import Text.PrettyPrint.Class
-import Text.Read (readMaybe)
--- import Paths_bittorrent (version)
-
--- TODO FIXME
-version :: Version
-version = Version [0, 0, 0, 3] []
-
--- | List of registered client versions + 'IlibHSbittorrent' (this
--- package) + 'IUnknown' (for not recognized software). All names are
--- prefixed by \"I\" because some of them starts from lowercase letter
--- but that is not a valid Haskell constructor name.
---
-data ClientImpl =
-   IUnknown
-
- | IMainline
-
- | IABC
- | IOspreyPermaseed
- | IBTQueue
- | ITribler
- | IShadow
- | IBitTornado
-
--- UPnP(!) Bit Torrent !???
--- 'U' - UPnP NAT Bit Torrent
- | IBitLord
- | IOpera
- | IMLdonkey
-
- | IAres
- | IArctic
- | IAvicora
- | IBitPump
- | IAzureus
- | IBitBuddy
- | IBitComet
- | IBitflu
- | IBTG
- | IBitRocket
- | IBTSlave
- | IBittorrentX
- | IEnhancedCTorrent
- | ICTorrent
- | IDelugeTorrent
- | IPropagateDataClient
- | IEBit
- | IElectricSheep
- | IFoxTorrent
- | IGSTorrent
- | IHalite
- | IlibHSbittorrent
- | IHydranode
- | IKGet
- | IKTorrent
- | ILH_ABC
- | ILphant
- | ILibtorrent
- | ILibTorrent
- | ILimeWire
- | IMonoTorrent
- | IMooPolice
- | IMiro
- | IMoonlightTorrent
- | INetTransport
- | IPando
- | IqBittorrent
- | IQQDownload
- | IQt4TorrentExample
- | IRetriever
- | IShareaza
- | ISwiftbit
- | ISwarmScope
- | ISymTorrent
- | Isharktorrent
- | ITorrentDotNET
- | ITransmission
- | ITorrentstorm
- | ITuoTu
- | IuLeecher
- | IuTorrent
- | IVagaa
- | IBitLet
- | IFireTorrent
- | IXunlei
- | IXanTorrent
- | IXtorrent
- | IZipTorrent
-   deriving (Show, Eq, Ord, Enum, Bounded)
-
--- | Used to represent a not recognized implementation
-instance Default ClientImpl where
-  def = IUnknown
-  {-# INLINE def #-}
-
--- | Example: @\"BitLet\" == 'IBitLet'@
-instance IsString ClientImpl where
-  fromString str
-    | Just impl <- L.lookup str alist = impl
-    | otherwise = error $ "fromString: not recognized " ++ str
-    where
-      alist = L.map mk [minBound..maxBound]
-      mk  x = (L.tail $ show x, x)
-
--- | Example: @pretty 'IBitLet' == \"IBitLet\"@
-instance Pretty ClientImpl where
-  pretty = text . L.tail . show
-
--- | Just the '0' version.
-instance Default Version where
-  def = Version [0] []
-  {-# INLINE def #-}
-
--- | For dot delimited version strings.
---   Example: @fromString \"0.1.0.2\" == Version [0, 1, 0, 2]@
---
-instance IsString Version where
-  fromString str
-    | Just nums <- chunkNums str = Version nums []
-    | otherwise = error $ "fromString: invalid version string " ++ str
-    where
-      chunkNums = sequence . L.map readMaybe . L.linesBy ('.' ==)
-
-instance Pretty Version where
-  pretty = text . showVersion
-
--- | The all sensible infomation that can be obtained from a peer
--- identifier or torrent /createdBy/ field.
-data Fingerprint = Fingerprint
-  { ciImpl    :: ClientImpl
-  , ciVersion :: Version
-  } deriving (Show, Eq, Ord)
-
--- | Unrecognized client implementation.
-instance Default Fingerprint where
-  def = Fingerprint def def
-  {-# INLINE def #-}
-
--- | Example: @\"BitComet-1.2\" == ClientInfo IBitComet (Version [1, 2] [])@
-instance IsString Fingerprint where
-  fromString str
-    | _ : ver <- _ver = Fingerprint (fromString impl) (fromString ver)
-    | otherwise = error $ "fromString: invalid client info string" ++ str
-    where
-      (impl, _ver) = L.span ((/=) '-') str
-
-instance Pretty Fingerprint where
-  pretty Fingerprint {..} = pretty ciImpl <+> "version" <+> pretty ciVersion
-
--- | Fingerprint of this (the bittorrent library) package. Normally,
--- applications should introduce its own fingerprints, otherwise they
--- can use 'libFingerprint' value.
---
-libFingerprint :: Fingerprint
-libFingerprint =  Fingerprint IlibHSbittorrent version
-
--- | HTTP user agent of this (the bittorrent library) package. Can be
--- used in HTTP tracker requests.
-libUserAgent :: String
-libUserAgent = render (pretty IlibHSbittorrent <> "/" <> pretty version)
-
-{-----------------------------------------------------------------------
---  For torrent file
------------------------------------------------------------------------}
--- TODO collect information about createdBy torrent field
-{-
-renderImpl :: ClientImpl -> Text
-renderImpl = T.pack . L.tail . show
-
-renderVersion :: Version -> Text
-renderVersion = undefined
-
-renderClientInfo :: ClientInfo -> Text
-renderClientInfo ClientInfo {..} = renderImpl ciImpl <> "/" <> renderVersion ciVersion
-
-parseClientInfo :: Text -> ClientImpl
-parseClientInfo t = undefined
--}
-{-
--- code used for generation; remove it later on
-
-mkEnumTyDef :: NM -> String
-mkEnumTyDef = unlines . map (" | I" ++) . nub . map snd
-
-mkPars :: NM -> String
-mkPars = unlines . map (\(code, impl) -> "  f \"" ++ code ++ "\" = " ++ "I" ++ impl)
-
-type NM = [(String, String)]
-nameMap :: NM
-nameMap =
- [ ("AG", "Ares")
- , ("A~", "Ares")
- , ("AR", "Arctic")
- , ("AV", "Avicora")
- , ("AX", "BitPump")
- , ("AZ", "Azureus")
- , ("BB", "BitBuddy")
- , ("BC", "BitComet")
- , ("BF", "Bitflu")
- , ("BG", "BTG")
- , ("BR", "BitRocket")
- , ("BS", "BTSlave")
- , ("BX", "BittorrentX")
- , ("CD", "EnhancedCTorrent")
- , ("CT", "CTorrent")
- , ("DE", "DelugeTorrent")
- , ("DP", "PropagateDataClient")
- , ("EB", "EBit")
- , ("ES", "ElectricSheep")
- , ("FT", "FoxTorrent")
- , ("GS", "GSTorrent")
- , ("HL", "Halite")
- , ("HS", "libHSnetwork_bittorrent")
- , ("HN", "Hydranode")
- , ("KG", "KGet")
- , ("KT", "KTorrent")
- , ("LH", "LH_ABC")
- , ("LP", "Lphant")
- , ("LT", "Libtorrent")
- , ("lt", "LibTorrent")
- , ("LW", "LimeWire")
- , ("MO", "MonoTorrent")
- , ("MP", "MooPolice")
- , ("MR", "Miro")
- , ("MT", "MoonlightTorrent")
- , ("NX", "NetTransport")
- , ("PD", "Pando")
- , ("qB", "qBittorrent")
- , ("QD", "QQDownload")
- , ("QT", "Qt4TorrentExample")
- , ("RT", "Retriever")
- , ("S~", "Shareaza")
- , ("SB", "Swiftbit")
- , ("SS", "SwarmScope")
- , ("ST", "SymTorrent")
- , ("st", "sharktorrent")
- , ("SZ", "Shareaza")
- , ("TN", "TorrentDotNET")
- , ("TR", "Transmission")
- , ("TS", "Torrentstorm")
- , ("TT", "TuoTu")
- , ("UL", "uLeecher")
- , ("UT", "uTorrent")
- , ("VG", "Vagaa")
- , ("WT", "BitLet")
- , ("WY", "FireTorrent")
- , ("XL", "Xunlei")
- , ("XT", "XanTorrent")
- , ("XX", "Xtorrent")
- , ("ZT", "ZipTorrent")
- ]
--}
diff --git a/src/Network/BitTorrent/Core/NodeInfo.hs b/src/Network/BitTorrent/Core/NodeInfo.hs
deleted file mode 100644
index fe17c097..00000000
--- a/src/Network/BitTorrent/Core/NodeInfo.hs
+++ /dev/null
@@ -1,219 +0,0 @@
--- |
---   Module      :  Network.BitTorrent.Core.Node
---   Copyright   :  (c) Sam Truzjan 2013
---                  (c) Daniel Gröber 2013
---   License     :  BSD3
---   Maintainer  :  pxqr.sta@gmail.com
---   Stability   :  experimental
---   Portability :  portable
---
---   A \"node\" is a client\/server listening on a UDP port
---   implementing the distributed hash table protocol. The DHT is
---   composed of nodes and stores the location of peers. BitTorrent
---   clients include a DHT node, which is used to contact other nodes
---   in the DHT to get the location of peers to download from using
---   the BitTorrent protocol.
---
-{-# LANGUAGE RecordWildCards            #-}
-{-# LANGUAGE FlexibleInstances          #-}
-{-# LANGUAGE TemplateHaskell            #-}
-{-# LANGUAGE GeneralizedNewtypeDeriving #-}
-{-# LANGUAGE DeriveDataTypeable         #-}
-{-# LANGUAGE DeriveFunctor              #-}
-module Network.BitTorrent.Core.NodeInfo
-       (  -- * Node ID
-         NodeId
-       , testIdBit
-       , genNodeId
-
-         -- ** Node distance
-       , NodeDistance
-       , distance
-
-         -- * Node address
-       , NodeAddr (..)
-
-         -- * Node info
-       , NodeInfo (..)
-       , rank
-       ) where
-
-import Control.Applicative
-import Data.Bits
-import Data.ByteString as BS
-import Data.ByteString.Char8 as BC
-import Data.ByteString.Base16 as Base16
-import Data.BEncode as BE
-import Data.Default
-import Data.Hashable
-import Data.Foldable
-import Data.IP
-import Data.List as L
-import Data.Monoid
-import Data.Ord
-import Data.Serialize as S
-import Data.String
-import Data.Typeable
-import Data.Word
-import Network
-import System.Entropy
-import Text.PrettyPrint as PP hiding ((<>))
-import Text.PrettyPrint.Class
-
-import Network.BitTorrent.Core.PeerAddr (PeerAddr (..))
-
-{-----------------------------------------------------------------------
---  Node id
------------------------------------------------------------------------}
--- TODO more compact representation ('ShortByteString's?)
-
--- | Each node has a globally unique identifier known as the \"node
--- ID.\"
---
---   Normally, /this/ node id should be saved between invocations
---   of the client software.
-newtype NodeId = NodeId ByteString
-  deriving (Show, Eq, Ord, BEncode, Typeable)
-
-nodeIdSize :: Int
-nodeIdSize = 20
-
--- | Meaningless node id, for testing purposes only.
-instance Default NodeId where
-  def = NodeId (BS.replicate nodeIdSize 0)
-
-instance Serialize NodeId where
-  get = NodeId <$> getByteString nodeIdSize
-  {-# INLINE get #-}
-  put (NodeId bs) = putByteString bs
-  {-# INLINE put #-}
-
--- | ASCII encoded.
-instance IsString NodeId where
-  fromString str
-    | L.length str == nodeIdSize = NodeId (fromString str)
-    |           otherwise = error "fromString: invalid NodeId length"
-  {-# INLINE fromString #-}
-
--- | base16 encoded.
-instance Pretty NodeId where
-  pretty (NodeId nid) = PP.text $ BC.unpack $ Base16.encode nid
-
--- | Test if the nth bit is set.
-testIdBit :: NodeId -> Word -> Bool
-testIdBit (NodeId bs) i
-  | fromIntegral i < nodeIdSize * 8
-  , (q, r) <- quotRem (fromIntegral i) 8
-  = testBit (BS.index bs q) r
-  |     otherwise      = False
-{-# INLINE testIdBit #-}
-
--- TODO WARN is the 'system' random suitable for this?
--- | Generate random NodeID used for the entire session.
---   Distribution of ID's should be as uniform as possible.
---
-genNodeId :: IO NodeId
-genNodeId = NodeId <$> getEntropy nodeIdSize
-
-{-----------------------------------------------------------------------
---  Node distance
------------------------------------------------------------------------}
-
--- | In Kademlia, the distance metric is XOR and the result is
--- interpreted as an unsigned integer.
-newtype NodeDistance = NodeDistance BS.ByteString
-  deriving (Eq, Ord)
-
-instance Pretty NodeDistance where
-  pretty (NodeDistance bs) = foldMap bitseq $ BS.unpack bs
-    where
-      listBits w = L.map (testBit w) (L.reverse [0..bitSize w - 1])
-      bitseq = foldMap (int . fromEnum) . listBits
-
--- | distance(A,B) = |A xor B| Smaller values are closer.
-distance :: NodeId -> NodeId -> NodeDistance
-distance (NodeId a) (NodeId b) = NodeDistance (BS.pack (BS.zipWith xor a b))
-
-{-----------------------------------------------------------------------
---  Node address
------------------------------------------------------------------------}
-
-data NodeAddr a = NodeAddr
-  { nodeHost ::                !a
-  , nodePort :: {-# UNPACK #-} !PortNumber
-  } deriving (Eq, Typeable, Functor)
-
-instance Show a => Show (NodeAddr a) where
-  showsPrec i NodeAddr {..}
-    = showsPrec i nodeHost <> showString ":" <> showsPrec i nodePort
-
-instance Read (NodeAddr IPv4) where
-  readsPrec i x = [ (fromPeerAddr a, s) | (a, s) <- readsPrec i x ]
-
--- | @127.0.0.1:6882@
-instance Default (NodeAddr IPv4) where
-  def = "127.0.0.1:6882"
-
--- | KRPC compatible encoding.
-instance Serialize a => Serialize (NodeAddr a) where
-  get = NodeAddr <$> get <*> get
-  {-# INLINE get #-}
-  put NodeAddr {..} = put nodeHost >> put nodePort
-  {-# INLINE put #-}
-
--- | Torrent file compatible encoding.
-instance BEncode a => BEncode (NodeAddr a) where
-  toBEncode NodeAddr {..} = toBEncode (nodeHost, nodePort)
-  {-# INLINE toBEncode #-}
-  fromBEncode b = uncurry NodeAddr <$> fromBEncode b
-  {-# INLINE fromBEncode #-}
-
-instance Hashable a => Hashable (NodeAddr a) where
-  hashWithSalt s NodeAddr {..} = hashWithSalt s (nodeHost, nodePort)
-  {-# INLINE hashWithSalt #-}
-
-instance Pretty ip => Pretty (NodeAddr ip) where
-  pretty NodeAddr {..} = pretty nodeHost <> ":" <> pretty nodePort
-
--- | Example:
---
---   @nodePort \"127.0.0.1:6881\" == 6881@
---
-instance IsString (NodeAddr IPv4) where
-  fromString = fromPeerAddr . fromString
-
-fromPeerAddr :: PeerAddr a -> NodeAddr a
-fromPeerAddr PeerAddr {..} = NodeAddr
-  { nodeHost = peerHost
-  , nodePort = peerPort
-  }
-
-{-----------------------------------------------------------------------
---  Node info
------------------------------------------------------------------------}
-
-data NodeInfo a = NodeInfo
-  { nodeId   :: !NodeId
-  , nodeAddr :: !(NodeAddr a)
-  } deriving (Show, Eq, Functor)
-
-instance Eq a => Ord (NodeInfo a) where
-  compare = comparing nodeId
-
--- | KRPC 'compact list' compatible encoding: contact information for
--- nodes is encoded as a 26-byte string. Also known as "Compact node
--- info" the 20-byte Node ID in network byte order has the compact
--- IP-address/port info concatenated to the end.
-instance Serialize a => Serialize (NodeInfo a) where
-  get = NodeInfo <$> get <*> get
-  put NodeInfo {..} = put nodeId >> put nodeAddr
-
-instance Pretty ip => Pretty (NodeInfo ip) where
-  pretty NodeInfo {..} = pretty nodeId <> "@(" <> pretty nodeAddr <> ")"
-
-instance Pretty ip => Pretty [NodeInfo ip] where
-  pretty = PP.vcat . PP.punctuate "," . L.map pretty
-
--- | Order by closeness: nearest nodes first.
-rank :: Eq ip => NodeId -> [NodeInfo ip] -> [NodeInfo ip]
-rank nid = L.sortBy (comparing (distance nid . nodeId))
diff --git a/src/Network/BitTorrent/Core/PeerAddr.hs b/src/Network/BitTorrent/Core/PeerAddr.hs
deleted file mode 100644
index 92fb83a7..00000000
--- a/src/Network/BitTorrent/Core/PeerAddr.hs
+++ /dev/null
@@ -1,354 +0,0 @@
--- |
---   Module      :  Network.BitTorrent.Core.PeerAddr
---   Copyright   :  (c) Sam Truzjan 2013
---                  (c) Daniel Gröber 2013
---   License     :  BSD3
---   Maintainer  :  pxqr.sta@gmail.com
---   Stability   :  provisional
---   Portability :  portable
---
---   'PeerAddr' is used to represent peer address. Currently it's
---   just peer IP and peer port but this might change in future.
---
-{-# LANGUAGE TemplateHaskell            #-}
-{-# LANGUAGE StandaloneDeriving         #-}
-{-# LANGUAGE GeneralizedNewtypeDeriving #-}
-{-# LANGUAGE DeriveDataTypeable         #-}
-{-# LANGUAGE FlexibleInstances          #-}
-{-# LANGUAGE DeriveFunctor              #-}
-{-# LANGUAGE ViewPatterns               #-}
-{-# OPTIONS -fno-warn-orphans           #-} -- for PortNumber instances
-module Network.BitTorrent.Core.PeerAddr
-       ( -- * Peer address
-         PeerAddr(..)
-       , defaultPorts
-       , peerSockAddr
-       , peerSocket
-
-         -- * Peer storage
-       , PeerStore
-       , Network.BitTorrent.Core.PeerAddr.lookup
-       , Network.BitTorrent.Core.PeerAddr.insert
-       ) where
-
-import Control.Applicative
-import Control.Monad
-import Data.BEncode   as BS
-import Data.BEncode.BDict (BKey)
-import Data.ByteString.Char8 as BS8
-import Data.Char
-import Data.Default
-import Data.Hashable
-import Data.HashMap.Strict as HM
-import Data.IP
-import Data.List      as L
-import Data.List.Split
-import Data.Maybe
-import Data.Monoid
-import Data.Serialize as S
-import Data.String
-import Data.Typeable
-import Data.Word
-import Network.Socket
-import Text.PrettyPrint as PP hiding ((<>))
-import Text.PrettyPrint.Class
-import Text.Read (readMaybe)
-import qualified Text.ParserCombinators.ReadP as RP
-
-import Data.Torrent.InfoHash
-import Network.BitTorrent.Core.PeerId
-
-
-{-----------------------------------------------------------------------
---  Port number
------------------------------------------------------------------------}
-
-instance BEncode PortNumber where
-  toBEncode   = toBEncode    .  fromEnum
-  fromBEncode = fromBEncode >=> portNumber
-    where
-      portNumber :: Integer -> BS.Result PortNumber
-      portNumber n
-        | 0 <= n && n <= fromIntegral (maxBound :: Word16)
-        = pure $ fromIntegral n
-        | otherwise = decodingError $ "PortNumber: " ++ show n
-
-instance Serialize PortNumber where
-  get = fromIntegral <$> getWord16be
-  {-# INLINE get #-}
-  put = putWord16be . fromIntegral
-  {-# INLINE put #-}
-
-instance Hashable PortNumber where
-  hashWithSalt s = hashWithSalt s . fromEnum
-  {-# INLINE hashWithSalt #-}
-
-instance Pretty PortNumber where
-  pretty = PP.int . fromEnum
-  {-# INLINE pretty #-}
-
-{-----------------------------------------------------------------------
---  IP addr
------------------------------------------------------------------------}
-
-class IPAddress i where
-  toHostAddr :: i -> Either HostAddress HostAddress6
-
-instance IPAddress IPv4 where
-  toHostAddr = Left . toHostAddress
-  {-# INLINE toHostAddr #-}
-
-instance IPAddress IPv6 where
-  toHostAddr = Right . toHostAddress6
-  {-# INLINE toHostAddr #-}
-
-instance IPAddress IP where
-  toHostAddr (IPv4 ip) = toHostAddr ip
-  toHostAddr (IPv6 ip) = toHostAddr ip
-  {-# INLINE toHostAddr #-}
-
-deriving instance Typeable IP
-deriving instance Typeable IPv4
-deriving instance Typeable IPv6
-
-ipToBEncode :: Show i => i -> BValue
-ipToBEncode ip = BString $ BS8.pack $ show ip
-{-# INLINE ipToBEncode #-}
-
-ipFromBEncode :: Read a => BValue -> BS.Result a
-ipFromBEncode (BString (BS8.unpack -> ipStr))
-  | Just ip <- readMaybe (ipStr) = pure ip
-  |         otherwise            = decodingError $ "IP: " ++ ipStr
-ipFromBEncode _    = decodingError $ "IP: addr should be a bstring"
-
-instance BEncode IP where
-  toBEncode   = ipToBEncode
-  {-# INLINE toBEncode #-}
-  fromBEncode = ipFromBEncode
-  {-# INLINE fromBEncode #-}
-
-instance BEncode IPv4 where
-  toBEncode   = ipToBEncode
-  {-# INLINE toBEncode #-}
-  fromBEncode = ipFromBEncode
-  {-# INLINE fromBEncode #-}
-
-instance BEncode IPv6 where
-  toBEncode   = ipToBEncode
-  {-# INLINE toBEncode #-}
-  fromBEncode = ipFromBEncode
-  {-# INLINE fromBEncode #-}
-
--- | When 'get'ing an IP it must be 'isolate'd to the appropriate
--- number of bytes since we have no other way of telling which
--- address type we are trying to parse
-instance Serialize IP where
-    put (IPv4 ip) = put ip
-    put (IPv6 ip) = put ip
-
-    get = do
-      n <- remaining
-      case n of
-        4  -> IPv4 <$> get
-        16 -> IPv6 <$> get
-        _ -> fail "Wrong number of bytes remaining to parse IP"
-
-instance Serialize IPv4 where
-    put = putWord32host    .  toHostAddress
-    get = fromHostAddress <$> getWord32host
-
-instance Serialize IPv6 where
-    put ip = put $ toHostAddress6 ip
-    get = fromHostAddress6 <$> get
-
-instance Pretty IPv4 where
-  pretty = PP.text . show
-  {-# INLINE pretty #-}
-
-instance Pretty IPv6 where
-  pretty = PP.text . show
-  {-# INLINE pretty #-}
-
-instance Pretty IP where
-  pretty = PP.text . show
-  {-# INLINE pretty #-}
-
-instance Hashable IPv4 where
-  hashWithSalt = hashUsing toHostAddress
-  {-# INLINE hashWithSalt #-}
-
-instance Hashable IPv6 where
-  hashWithSalt s a = hashWithSalt s (toHostAddress6 a)
-
-instance Hashable IP where
-  hashWithSalt s (IPv4 h) = hashWithSalt s h
-  hashWithSalt s (IPv6 h) = hashWithSalt s h
-
-{-----------------------------------------------------------------------
---  Peer addr
------------------------------------------------------------------------}
--- TODO check semantic of ord and eq instances
-
--- | Peer address info normally extracted from peer list or peer
--- compact list encoding.
-data PeerAddr a = PeerAddr
-  { peerId   :: !(Maybe PeerId)
-
-    -- | This is usually 'IPv4', 'IPv6', 'IP' or unresolved
-    -- 'HostName'.
-  , peerHost :: !a
-
-    -- | The port the peer listenning for incoming P2P sessions.
-  , peerPort :: {-# UNPACK #-} !PortNumber
-  } deriving (Show, Eq, Ord, Typeable, Functor)
-
-peer_ip_key, peer_id_key, peer_port_key :: BKey
-peer_ip_key   = "ip"
-peer_id_key   = "peer id"
-peer_port_key = "port"
-
--- | The tracker's 'announce response' compatible encoding.
-instance (Typeable a, BEncode a) => BEncode (PeerAddr a) where
-  toBEncode PeerAddr {..} = toDict $
-       peer_ip_key   .=! peerHost
-    .: peer_id_key   .=? peerId
-    .: peer_port_key .=! peerPort
-    .: endDict
-
-  fromBEncode = fromDict $ do
-    peerAddr <$>! peer_ip_key
-             <*>? peer_id_key
-             <*>! peer_port_key
-    where
-      peerAddr = flip PeerAddr
-
--- | The tracker's 'compact peer list' compatible encoding. The
--- 'peerId' is always 'Nothing'.
---
---   For more info see: <http://www.bittorrent.org/beps/bep_0023.html>
---
--- TODO: test byte order
-instance (Serialize a) => Serialize (PeerAddr a) where
-  put PeerAddr {..} = put peerHost >> put peerPort
-  get = PeerAddr Nothing <$> get <*> get
-
--- | @127.0.0.1:6881@
-instance Default (PeerAddr IPv4) where
-  def = "127.0.0.1:6881"
-
--- | @127.0.0.1:6881@
-instance Default (PeerAddr IP) where
-  def = IPv4 <$> def
-
--- | Example:
---
---   @peerPort \"127.0.0.1:6881\" == 6881@
---
-instance IsString (PeerAddr IPv4) where
-  fromString str
-    | [hostAddrStr, portStr] <- splitWhen (== ':') str
-    , Just hostAddr <- readMaybe hostAddrStr
-    , Just portNum  <- toEnum <$> readMaybe portStr
-                = PeerAddr Nothing hostAddr portNum
-    | otherwise = error $ "fromString: unable to parse (PeerAddr IPv4): " ++ str
-
-instance Read (PeerAddr IPv4) where
-  readsPrec i = RP.readP_to_S $ do
-    ipv4 <- RP.readS_to_P (readsPrec i)
-    _    <- RP.char ':'
-    port <- toEnum <$> RP.readS_to_P (readsPrec i)
-    return $ PeerAddr Nothing ipv4 port
-
-readsIPv6_port :: String -> [((IPv6, PortNumber), String)]
-readsIPv6_port = RP.readP_to_S $ do
-  ip <- RP.char '[' *> (RP.readS_to_P reads) <* RP.char ']'
-  _ <- RP.char ':'
-  port <- toEnum <$> read <$> (RP.many1 $ RP.satisfy isDigit) <* RP.eof
-  return (ip,port)
-
-instance IsString (PeerAddr IPv6) where
-  fromString str
-    | [((ip,port),"")] <- readsIPv6_port str =
-        PeerAddr Nothing ip port
-    | otherwise = error $ "fromString: unable to parse (PeerAddr IPv6): " ++ str
-
-instance IsString (PeerAddr IP) where
-  fromString str
-    | '[' `L.elem` str = IPv6 <$> fromString str
-    |      otherwise   = IPv4 <$> fromString str
-
--- | fingerprint + "at" + dotted.host.inet.addr:port
--- TODO: instances for IPv6, HostName
-instance Pretty a => Pretty (PeerAddr a) where
-  pretty PeerAddr {..}
-    | Just pid <- peerId = pretty (fingerprint pid) <+> "at" <+> paddr
-    |     otherwise      = paddr
-    where
-      paddr = pretty peerHost <> ":" <> text (show peerPort)
-
-instance Hashable a => Hashable (PeerAddr a) where
-  hashWithSalt s PeerAddr {..} =
-    s `hashWithSalt` peerId `hashWithSalt` peerHost `hashWithSalt` peerPort
-
--- | Ports typically reserved for bittorrent P2P listener.
-defaultPorts :: [PortNumber]
-defaultPorts =  [6881..6889]
-
-_resolvePeerAddr :: (IPAddress i) => PeerAddr HostName -> PeerAddr i
-_resolvePeerAddr = undefined
-
-_peerSockAddr :: PeerAddr IP -> (Family, SockAddr)
-_peerSockAddr PeerAddr {..} =
-    case peerHost of
-          IPv4 ipv4 ->
-              (AF_INET, SockAddrInet peerPort (toHostAddress  ipv4))
-          IPv6 ipv6 ->
-              (AF_INET6, SockAddrInet6 peerPort 0 (toHostAddress6 ipv6) 0)
-
-peerSockAddr :: PeerAddr IP -> SockAddr
-peerSockAddr = snd . _peerSockAddr
-
--- | Create a socket connected to the address specified in a peerAddr
-peerSocket :: SocketType -> PeerAddr IP -> IO Socket
-peerSocket socketType pa = do
-    let (family, addr) = _peerSockAddr pa
-    sock <- socket family socketType defaultProtocol
-    connect sock addr
-    return sock
-
-{-----------------------------------------------------------------------
---  Peer storage
------------------------------------------------------------------------}
--- TODO use more memory efficient representation
-
--- | Storage used to keep track a set of known peers in client,
--- tracker or DHT sessions.
-newtype PeerStore ip = PeerStore (HashMap InfoHash [PeerAddr ip])
-
--- | Empty store.
-instance Default (PeerStore a) where
-  def = PeerStore HM.empty
-  {-# INLINE def #-}
-
--- | Monoid under union operation.
-instance Eq a => Monoid (PeerStore a) where
-  mempty  = def
-  {-# INLINE mempty #-}
-
-  mappend (PeerStore a) (PeerStore b) =
-    PeerStore (HM.unionWith L.union a b)
-  {-# INLINE mappend #-}
-
--- | Can be used to store peers between invocations of the client
--- software.
-instance Serialize (PeerStore a) where
-  get = undefined
-  put = undefined
-
--- | Used in 'get_peers' DHT queries.
-lookup :: InfoHash -> PeerStore a -> [PeerAddr a]
-lookup ih (PeerStore m) = fromMaybe [] $ HM.lookup ih m
-
--- | Used in 'announce_peer' DHT queries.
-insert :: Eq a => InfoHash -> PeerAddr a -> PeerStore a -> PeerStore a
-insert ih a (PeerStore m) = PeerStore (HM.insertWith L.union ih [a] m)
diff --git a/src/Network/BitTorrent/Core/PeerId.hs b/src/Network/BitTorrent/Core/PeerId.hs
deleted file mode 100644
index a180ff30..00000000
--- a/src/Network/BitTorrent/Core/PeerId.hs
+++ /dev/null
@@ -1,364 +0,0 @@
--- |
---   Copyright   :  (c) Sam Truzjan 2013
---   License     :  BSD3
---   Maintainer  :  pxqr.sta@gmail.com
---   Stability   :  experimental
---   Portability :  portable
---
---  'PeerID' represent self assigned peer identificator. Ideally each
---  host in the network should have unique peer id to avoid
---  collisions, therefore for peer ID generation we use good entropy
---  source. Peer ID is sent in /tracker request/, sent and received in
---  /peer handshakes/ and used in DHT queries.
---
-{-# LANGUAGE GeneralizedNewtypeDeriving #-}
-{-# LANGUAGE MultiParamTypeClasses      #-}
-{-# LANGUAGE DeriveDataTypeable         #-}
-module Network.BitTorrent.Core.PeerId
-       ( -- * PeerId
-         PeerId
-
-         -- * Generation
-       , genPeerId
-       , timestamp
-       , entropy
-
-         -- * Encoding
-       , azureusStyle
-       , shadowStyle
-       , defaultClientId
-       , defaultVersionNumber
-
-         -- * Decoding
-       , fingerprint
-       ) where
-
-import Control.Applicative
-import Data.BEncode as BE
-import Data.ByteString as BS
-import Data.ByteString.Internal as BS
-import Data.ByteString.Char8 as BC
-import qualified Data.ByteString.Lazy as BL
-import qualified Data.ByteString.Lazy.Builder as BS
-import Data.Convertible
-import Data.Default
-import Data.Foldable    (foldMap)
-import Data.List as L
-import Data.List.Split as L
-import Data.Maybe       (fromMaybe, catMaybes)
-import Data.Monoid
-import Data.Hashable
-import Data.Serialize as S
-import Data.String
-import Data.Time.Clock  (getCurrentTime)
-import Data.Time.Format (formatTime)
-import Data.Typeable
-import Data.Version     (Version(Version), versionBranch)
-import Network.HTTP.Types.QueryLike
-import System.Entropy   (getEntropy)
-import System.Locale    (defaultTimeLocale)
-import Text.PrettyPrint hiding ((<>))
-import Text.PrettyPrint.Class
-import Text.Read        (readMaybe)
-
-import Network.BitTorrent.Core.Fingerprint
-
--- TODO use unpacked Word160 form (length is known statically)
-
--- | Peer identifier is exactly 20 bytes long bytestring.
-newtype PeerId = PeerId { getPeerId :: ByteString }
-  deriving (Show, Eq, Ord, BEncode, Typeable)
-
-peerIdLen :: Int
-peerIdLen = 20
-
--- | For testing purposes only.
-instance Default PeerId where
-  def = azureusStyle defaultClientId defaultVersionNumber ""
-
-instance Hashable PeerId where
-  hashWithSalt = hashUsing getPeerId
-  {-# INLINE hashWithSalt #-}
-
-instance Serialize PeerId where
-  put = putByteString . getPeerId
-  get = PeerId <$> getBytes peerIdLen
-
-instance QueryValueLike PeerId where
-  toQueryValue (PeerId pid) = Just pid
-  {-# INLINE toQueryValue #-}
-
-instance IsString PeerId where
-  fromString str
-      | BS.length bs == peerIdLen = PeerId bs
-      | otherwise = error $ "Peer id should be 20 bytes long: " ++ show str
-    where
-      bs = fromString str
-
-instance Pretty PeerId where
-  pretty = text . BC.unpack . getPeerId
-
-instance Convertible BS.ByteString PeerId where
-  safeConvert bs
-    | BS.length bs == peerIdLen = pure (PeerId bs)
-    |          otherwise        = convError "invalid length" bs
-
-{-----------------------------------------------------------------------
---  Encoding
------------------------------------------------------------------------}
-
--- | Pad bytestring so it's becomes exactly request length. Conversion
--- is done like so:
---
---     * length < size: Complete bytestring by given charaters.
---
---     * length = size: Output bytestring as is.
---
---     * length > size: Drop last (length - size) charaters from a
---     given bytestring.
---
-byteStringPadded :: ByteString -- ^ bytestring to be padded.
-                 -> Int        -- ^ size of result builder.
-                 -> Char       -- ^ character used for padding.
-                 -> BS.Builder
-byteStringPadded bs s c =
-      BS.byteString (BS.take s bs) <>
-      BS.byteString (BC.replicate padLen c)
-  where
-    padLen = s - min (BS.length bs) s
-
--- | Azureus-style encoding have the following layout:
---
---     * 1  byte : '-'
---
---     * 2  bytes: client id
---
---     * 4  bytes: version number
---
---     * 1  byte : '-'
---
---     * 12 bytes: random number
---
-azureusStyle :: ByteString -- ^ 2 character client ID, padded with 'H'.
-             -> ByteString -- ^ Version number, padded with 'X'.
-             -> ByteString -- ^ Random number, padded with '0'.
-             -> PeerId     -- ^ Azureus-style encoded peer ID.
-azureusStyle cid ver rnd = PeerId $ BL.toStrict $ BS.toLazyByteString $
-    BS.char8 '-' <>
-      byteStringPadded cid 2  'H' <>
-      byteStringPadded ver 4  'X' <>
-    BS.char8 '-' <>
-      byteStringPadded rnd 12 '0'
-
--- | Shadow-style encoding have the following layout:
---
---     * 1 byte   : client id.
---
---     * 0-4 bytes: version number. If less than 4 then padded with
---     '-' char.
---
---     * 15 bytes : random number. If length is less than 15 then
---     padded with '0' char.
---
-shadowStyle :: Char       -- ^ Client ID.
-            -> ByteString -- ^ Version number.
-            -> ByteString -- ^ Random number.
-            -> PeerId     -- ^ Shadow style encoded peer ID.
-shadowStyle cid ver rnd = PeerId $ BL.toStrict $ BS.toLazyByteString $
-    BS.char8 cid <>
-      byteStringPadded ver 4  '-' <>
-      byteStringPadded rnd 15 '0'
-
-
--- | 'HS'- 2 bytes long client identifier.
-defaultClientId :: ByteString
-defaultClientId = "HS"
-
--- | Gives exactly 4 bytes long version number for any version of the
--- package.  Version is taken from .cabal file.
-defaultVersionNumber :: ByteString
-defaultVersionNumber = BS.take 4 $ BC.pack $ foldMap show $
-                         versionBranch $ ciVersion libFingerprint
-
-{-----------------------------------------------------------------------
---  Generation
------------------------------------------------------------------------}
-
--- | Gives 15 characters long decimal timestamp such that:
---
---     * 6 bytes   : first 6 characters from picoseconds obtained with %q.
---
---     * 1 byte    : character \'.\' for readability.
---
---     * 9..* bytes: number of whole seconds since the Unix epoch
---     (!)REVERSED.
---
---   Can be used both with shadow and azureus style encoding. This
---   format is used to make the ID's readable for debugging purposes.
---
-timestamp :: IO ByteString
-timestamp = (BC.pack . format) <$> getCurrentTime
-  where
-    format t = L.take 6 (formatTime defaultTimeLocale "%q" t) ++ "." ++
-               L.take 9 (L.reverse (formatTime defaultTimeLocale "%s" t))
-
--- | Gives 15 character long random bytestring. This is more robust
--- method for generation of random part of peer ID than 'timestamp'.
-entropy :: IO ByteString
-entropy = getEntropy 15
-
--- NOTE: entropy generates incorrrect peer id
-
--- |  Here we use 'azureusStyle' encoding with the following args:
---
---      * 'HS' for the client id; ('defaultClientId')
---
---      * Version of the package for the version number;
---      ('defaultVersionNumber')
---
---      * UTC time day ++ day time for the random number. ('timestamp')
---
-genPeerId :: IO PeerId
-genPeerId = azureusStyle defaultClientId defaultVersionNumber <$> timestamp
-
-{-----------------------------------------------------------------------
---  Decoding
------------------------------------------------------------------------}
-
-parseImpl :: ByteString -> ClientImpl
-parseImpl = f . BC.unpack
- where
-  f "AG" = IAres
-  f "A~" = IAres
-  f "AR" = IArctic
-  f "AV" = IAvicora
-  f "AX" = IBitPump
-  f "AZ" = IAzureus
-  f "BB" = IBitBuddy
-  f "BC" = IBitComet
-  f "BF" = IBitflu
-  f "BG" = IBTG
-  f "BR" = IBitRocket
-  f "BS" = IBTSlave
-  f "BX" = IBittorrentX
-  f "CD" = IEnhancedCTorrent
-  f "CT" = ICTorrent
-  f "DE" = IDelugeTorrent
-  f "DP" = IPropagateDataClient
-  f "EB" = IEBit
-  f "ES" = IElectricSheep
-  f "FT" = IFoxTorrent
-  f "GS" = IGSTorrent
-  f "HL" = IHalite
-  f "HS" = IlibHSbittorrent
-  f "HN" = IHydranode
-  f "KG" = IKGet
-  f "KT" = IKTorrent
-  f "LH" = ILH_ABC
-  f "LP" = ILphant
-  f "LT" = ILibtorrent
-  f "lt" = ILibTorrent
-  f "LW" = ILimeWire
-  f "MO" = IMonoTorrent
-  f "MP" = IMooPolice
-  f "MR" = IMiro
-  f "ML" = IMLdonkey
-  f "MT" = IMoonlightTorrent
-  f "NX" = INetTransport
-  f "PD" = IPando
-  f "qB" = IqBittorrent
-  f "QD" = IQQDownload
-  f "QT" = IQt4TorrentExample
-  f "RT" = IRetriever
-  f "S~" = IShareaza
-  f "SB" = ISwiftbit
-  f "SS" = ISwarmScope
-  f "ST" = ISymTorrent
-  f "st" = Isharktorrent
-  f "SZ" = IShareaza
-  f "TN" = ITorrentDotNET
-  f "TR" = ITransmission
-  f "TS" = ITorrentstorm
-  f "TT" = ITuoTu
-  f "UL" = IuLeecher
-  f "UT" = IuTorrent
-  f "VG" = IVagaa
-  f "WT" = IBitLet
-  f "WY" = IFireTorrent
-  f "XL" = IXunlei
-  f "XT" = IXanTorrent
-  f "XX" = IXtorrent
-  f "ZT" = IZipTorrent
-  f _    = IUnknown
-
--- TODO use regexps
-
--- | Tries to extract meaningful information from peer ID bytes. If
--- peer id uses unknown coding style then client info returned is
--- 'def'.
---
-fingerprint :: PeerId -> Fingerprint
-fingerprint pid = either (const def) id $ runGet getCI (getPeerId pid)
-  where
-    getCI    = do
-      leading <- BS.w2c <$> getWord8
-      case leading of
-        '-' -> Fingerprint <$> getAzureusImpl <*> getAzureusVersion
-        'M' -> Fingerprint <$> pure IMainline <*> getMainlineVersion
-        'e' -> Fingerprint <$> getBitCometImpl <*> getBitCometVersion
-        'F' -> Fingerprint <$> getBitCometImpl <*> getBitCometVersion
-        c   -> do
-          c1 <- w2c <$> S.lookAhead getWord8
-          if c1 == 'P'
-            then do
-                 _ <- getWord8
-                 Fingerprint <$> pure IOpera            <*> getOperaVersion
-            else Fingerprint <$> pure (getShadowImpl c) <*> getShadowVersion
-
-    getMainlineVersion = do
-      str <- BC.unpack <$> getByteString 7
-      let mnums = L.filter (not . L.null) $ L.linesBy ('-' ==) str
-      return $ Version (fromMaybe [] $ sequence $ L.map readMaybe mnums) []
-
-    getAzureusImpl    = parseImpl <$> getByteString 2
-    getAzureusVersion = mkVer     <$> getByteString 4
-      where
-        mkVer bs = Version [fromMaybe 0 $ readMaybe $ BC.unpack bs] []
-
-    getBitCometImpl = do
-      bs <- getByteString 3
-      S.lookAhead $ do
-        _  <- getByteString 2
-        lr <- getByteString 4
-        return $
-          if lr == "LORD" then IBitLord  else
-          if bs == "UTB"  then IBitComet else
-          if bs == "xbc"  then IBitComet else def
-
-    getBitCometVersion = do
-      x <- getWord8
-      y <- getWord8
-      return $ Version [fromIntegral x, fromIntegral y] []
-
-    getOperaVersion = do
-      str <- BC.unpack <$> getByteString 4
-      return $ Version [fromMaybe 0 $ readMaybe str] []
-
-    getShadowImpl 'A' = IABC
-    getShadowImpl 'O' = IOspreyPermaseed
-    getShadowImpl 'Q' = IBTQueue
-    getShadowImpl 'R' = ITribler
-    getShadowImpl 'S' = IShadow
-    getShadowImpl 'T' = IBitTornado
-    getShadowImpl  _  = IUnknown
-
-    decodeShadowVerNr :: Char -> Maybe Int
-    decodeShadowVerNr c
-      | '0' < c && c <= '9' = Just  (fromEnum c - fromEnum '0')
-      | 'A' < c && c <= 'Z' = Just ((fromEnum c - fromEnum 'A') + 10)
-      | 'a' < c && c <= 'z' = Just ((fromEnum c - fromEnum 'a') + 36)
-      |        otherwise    = Nothing
-
-    getShadowVersion = do
-      str <- BC.unpack <$> getByteString 5
-      return $ Version (catMaybes $ L.map decodeShadowVerNr str) []
diff --git a/src/Network/BitTorrent/DHT.hs b/src/Network/BitTorrent/DHT.hs
index f587f7c8..39b33478 100644
--- a/src/Network/BitTorrent/DHT.hs
+++ b/src/Network/BitTorrent/DHT.hs
@@ -62,9 +62,8 @@ import Data.Conduit as C
 import Data.Conduit.List as C
 import Network.Socket
 
-import Data.Torrent (tNodes)
-import Data.Torrent.InfoHash
-import Network.BitTorrent.Core
+import Data.Torrent
+import Network.BitTorrent.Address
 import Network.BitTorrent.DHT.Query
 import Network.BitTorrent.DHT.Session
 import Network.BitTorrent.DHT.Routing as T
diff --git a/src/Network/BitTorrent/DHT/ContactInfo.hs b/src/Network/BitTorrent/DHT/ContactInfo.hs
index 028a4214..baa240b4 100644
--- a/src/Network/BitTorrent/DHT/ContactInfo.hs
+++ b/src/Network/BitTorrent/DHT/ContactInfo.hs
@@ -1,10 +1,24 @@
 module Network.BitTorrent.DHT.ContactInfo
-       (        ) where
+       ( PeerStore
+       , Network.BitTorrent.DHT.ContactInfo.lookup
+       , Network.BitTorrent.DHT.ContactInfo.insert
+       ) where
+
+import Data.Default
+import Data.List as L
+import Data.Maybe
+import Data.Monoid
+import Data.HashMap.Strict as HM
+import Data.Serialize
+
+import Data.Torrent
+import Network.BitTorrent.Address
+
 {-
 import Data.HashMap.Strict as HM
 
 import Data.Torrent.InfoHash
-import Network.BitTorrent.Core
+import Network.BitTorrent.Address
 
 -- increase prefix when table is too large
 -- decrease prefix when table is too small
@@ -90,4 +104,36 @@ prune pref targetSize (Tip _ _) = undefined
 -- | Remove expired entries.
 splitGT :: Timestamp -> ContactInfo ip -> ContactInfo ip
 splitGT = undefined
--}
\ No newline at end of file
+-}
+
+-- | Storage used to keep track a set of known peers in client,
+-- tracker or DHT sessions.
+newtype PeerStore ip = PeerStore (HashMap InfoHash [PeerAddr ip])
+
+-- | Empty store.
+instance Default (PeerStore a) where
+  def = PeerStore HM.empty
+  {-# INLINE def #-}
+
+-- | Monoid under union operation.
+instance Eq a => Monoid (PeerStore a) where
+  mempty  = def
+  {-# INLINE mempty #-}
+
+  mappend (PeerStore a) (PeerStore b) =
+    PeerStore (HM.unionWith L.union a b)
+  {-# INLINE mappend #-}
+
+-- | Can be used to store peers between invocations of the client
+-- software.
+instance Serialize (PeerStore a) where
+  get = undefined
+  put = undefined
+
+-- | Used in 'get_peers' DHT queries.
+lookup :: InfoHash -> PeerStore a -> [PeerAddr a]
+lookup ih (PeerStore m) = fromMaybe [] $ HM.lookup ih m
+
+-- | Used in 'announce_peer' DHT queries.
+insert :: Eq a => InfoHash -> PeerAddr a -> PeerStore a -> PeerStore a
+insert ih a (PeerStore m) = PeerStore (HM.insertWith L.union ih [a] m)
diff --git a/src/Network/BitTorrent/DHT/Message.hs b/src/Network/BitTorrent/DHT/Message.hs
index 7bcd00f0..145141ee 100644
--- a/src/Network/BitTorrent/DHT/Message.hs
+++ b/src/Network/BitTorrent/DHT/Message.hs
@@ -92,8 +92,8 @@ import Data.Typeable
 import Network
 import Network.KRPC
 
-import Data.Torrent.InfoHash
-import Network.BitTorrent.Core
+import Data.Torrent
+import Network.BitTorrent.Address
 import Network.BitTorrent.DHT.Token
 import Network.KRPC ()
 
diff --git a/src/Network/BitTorrent/DHT/Query.hs b/src/Network/BitTorrent/DHT/Query.hs
index 48dfc15a..d4710ecf 100644
--- a/src/Network/BitTorrent/DHT/Query.hs
+++ b/src/Network/BitTorrent/DHT/Query.hs
@@ -56,8 +56,8 @@ import Text.PrettyPrint as PP hiding ((<>), ($$))
 import Text.PrettyPrint.Class
 
 import Network.KRPC hiding (Options, def)
-import Data.Torrent.InfoHash
-import Network.BitTorrent.Core
+import Data.Torrent
+import Network.BitTorrent.Address
 import Network.BitTorrent.DHT.Message
 import Network.BitTorrent.DHT.Routing
 import Network.BitTorrent.DHT.Session
diff --git a/src/Network/BitTorrent/DHT/Routing.hs b/src/Network/BitTorrent/DHT/Routing.hs
index 106aec31..ee295125 100644
--- a/src/Network/BitTorrent/DHT/Routing.hs
+++ b/src/Network/BitTorrent/DHT/Routing.hs
@@ -73,8 +73,8 @@ import GHC.Generics
 import Text.PrettyPrint as PP hiding ((<>))
 import Text.PrettyPrint.Class
 
-import Data.Torrent.InfoHash
-import Network.BitTorrent.Core
+import Data.Torrent
+import Network.BitTorrent.Address
 
 {-----------------------------------------------------------------------
 --  Routing monad
diff --git a/src/Network/BitTorrent/DHT/Session.hs b/src/Network/BitTorrent/DHT/Session.hs
index e770b1d3..208f8ec8 100644
--- a/src/Network/BitTorrent/DHT/Session.hs
+++ b/src/Network/BitTorrent/DHT/Session.hs
@@ -75,6 +75,7 @@ import Control.Monad.Logger
 import Control.Monad.Reader
 import Control.Monad.Trans.Control
 import Control.Monad.Trans.Resource
+import Data.Conduit.Lazy
 import Data.Default
 import Data.Fixed
 import Data.Hashable
@@ -91,11 +92,11 @@ import System.Random (randomIO)
 import Text.PrettyPrint as PP hiding ((<>), ($$))
 import Text.PrettyPrint.Class
 
-import Data.Torrent.InfoHash
+import Data.Torrent as Torrent
 import Network.KRPC hiding (Options, def)
 import qualified Network.KRPC as KRPC (def)
-import Network.BitTorrent.Core
-import Network.BitTorrent.Core.PeerAddr as P
+import Network.BitTorrent.Address
+import Network.BitTorrent.DHT.ContactInfo as P
 import Network.BitTorrent.DHT.Message
 import Network.BitTorrent.DHT.Routing as R
 import Network.BitTorrent.DHT.Token   as T
@@ -253,10 +254,8 @@ data Node ip = Node
 -- | DHT keep track current session and proper resource allocation for
 -- safe multithreading.
 newtype DHT ip a = DHT { unDHT :: ReaderT (Node ip) IO a }
-  deriving ( Functor, Applicative, Monad
-           , MonadIO, MonadBase IO
-           , MonadReader (Node ip)
-           , MonadThrow, MonadUnsafeIO
+  deriving ( Functor, Applicative, Monad, MonadIO
+           , MonadBase IO, MonadReader (Node ip), MonadThrow
            )
 
 instance MonadBaseControl IO (DHT ip) where
diff --git a/src/Network/BitTorrent/DHT/Token.hs b/src/Network/BitTorrent/DHT/Token.hs
index a38456fd..a0ed428b 100644
--- a/src/Network/BitTorrent/DHT/Token.hs
+++ b/src/Network/BitTorrent/DHT/Token.hs
@@ -50,7 +50,7 @@ import Data.String
 import Data.Time
 import System.Random
 
-import Network.BitTorrent.Core
+import Network.BitTorrent.Address
 
 -- TODO use ShortByteString
 
diff --git a/src/Network/BitTorrent/Exchange/Assembler.hs b/src/Network/BitTorrent/Exchange/Assembler.hs
deleted file mode 100644
index e5834948..00000000
--- a/src/Network/BitTorrent/Exchange/Assembler.hs
+++ /dev/null
@@ -1,168 +0,0 @@
--- |
---   Copyright   :  (c) Sam Truzjan 2013
---   License     :  BSD3
---   Maintainer  :  pxqr.sta@gmail.com
---   Stability   :  experimental
---   Portability :  portable
---
---   Assembler is used to build pieces from blocks. In general
---   'Assembler' should be used to handle 'Transfer' messages when
---
---   A block can have one of the following status:
---
---     1) /not allowed/: Piece is not in download set. 'null' and 'empty'.
---
---
---     2) /waiting/: (allowed?) Block have been allowed to download,
---     but /this/ peer did not send any 'Request' message for this
---     block. To allow some piece use
---     'Network.BitTorrent.Exchange.Selector' and then 'allowedSet'
---     and 'allowPiece'.
---
---     3) /inflight/: (pending?) Block have been requested but
---     /remote/ peer did not send any 'Piece' message for this block.
---     Related functions 'markInflight'
---
---     4) /pending/: (stalled?) Block have have been downloaded
---     Related functions 'insertBlock'.
---
---   Piece status:
---
---     1) /assembled/: (downloaded?) All blocks in piece have been
---     downloaded but the piece did not verified yet.
---
---       * Valid: go to completed;
---
---       * Invalid: go to waiting.
---
---     2) /corrupted/:
---
---     3) /downloaded/: (verified?) A piece have been successfully
---     verified via the hash. Usually the piece should be stored to
---     the 'System.Torrent.Storage' and /this/ peer should send 'Have'
---     messages to the /remote/ peers.
---
-{-# LANGUAGE TemplateHaskell #-}
-module Network.BitTorrent.Exchange.Assembler
-       ( -- * Assembler
-         Assembler
-
-         -- * Query
-       , Network.BitTorrent.Exchange.Assembler.null
-       , Network.BitTorrent.Exchange.Assembler.size
-
-         -- *
-       , Network.BitTorrent.Exchange.Assembler.empty
-       , allowPiece
-
-         -- * Debugging
-       , Network.BitTorrent.Exchange.Assembler.valid
-       ) where
-
-import Control.Applicative
-import Control.Lens
-import Data.IntMap.Strict as IM
-import Data.List as L
-import Data.Map as M
-import Data.Maybe
-import Data.IP
-
-import Data.Torrent.Piece
-import Network.BitTorrent.Core
-import Network.BitTorrent.Exchange.Block as B
-
-{-----------------------------------------------------------------------
---  Assembler
------------------------------------------------------------------------}
-
-type Timestamp = ()
-{-
-data BlockRequest = BlockRequest
-  { requestSent    :: Timestamp
-  , requestedPeer  :: PeerAddr IP
-  , requestedBlock :: BlockIx
-  }
--}
-type BlockRange = (BlockOffset, BlockSize)
-type PieceMap = IntMap
-
-data Assembler = Assembler
-  { -- | A set of blocks that have been 'Request'ed but not yet acked.
-    _inflight :: Map (PeerAddr IP) (PieceMap [BlockRange])
-
-    -- | A set of blocks that but not yet assembled.
-  , _pending  :: PieceMap Bucket
-
-    -- | Used for validation of assembled pieces.
-  , info      :: PieceInfo
-  }
-
-$(makeLenses ''Assembler)
-
-
-valid :: Assembler -> Bool
-valid = undefined
-
-data Result a
-  = Completed   (Piece a)
-  | Corrupted    PieceIx
-  | NotRequested PieceIx
-  | Overlapped   BlockIx
-
-null :: Assembler -> Bool
-null = undefined
-
-size :: Assembler -> Bool
-size = undefined
-
-empty :: PieceInfo -> Assembler
-empty = Assembler M.empty IM.empty
-
-allowPiece :: PieceIx -> Assembler -> Assembler
-allowPiece pix a @ Assembler {..}  = over pending (IM.insert pix bkt) a
-  where
-    bkt = B.empty (piPieceLength info)
-
-allowedSet :: (PeerAddr IP) -> Assembler -> [BlockIx]
-allowedSet = undefined
-
---inflight :: PeerAddr -> BlockIx -> Assembler -> Assembler
---inflight = undefined
-
---  You should check if a returned by peer block is actually have
--- been requested and in-flight. This is needed to avoid "I send
--- random corrupted block" attacks.
-insert :: PeerAddr IP -> Block a -> Assembler -> Assembler
-insert = undefined
-
-{-
-insert :: Block a -> Assembler a -> (Assembler a, Maybe (Result a))
-insert blk @ Block {..} a @ Assembler {..} = undefined
-{-
-  = let (pending, mpiece) = inserta blk piecePending
-    in (Assembler inflightSet pending pieceInfo, f <$> mpiece)
-  where
-    f p = undefined
---      | checkPieceLazy pieceInfo p = Assembled p
---      |          otherwise         = Corrupted ixPiece
--}
-
-
-inflightPieces :: Assembler a -> [PieceIx]
-inflightPieces Assembler {..} = IM.keys piecePending
-
-completeBlocks :: PieceIx -> Assembler a -> [Block a]
-completeBlocks pix Assembler {..}  = fromMaybe [] $ IM.lookup pix piecePending
-
-incompleteBlocks :: PieceIx -> Assembler a -> [BlockIx]
-incompleteBlocks = undefined
-
-nextBlock :: Assembler a -> Maybe (Assembler a, BlockIx)
-nextBlock Assembler {..} = undefined
-
-inserta :: Block a
-        -> PieceMap [Block a]
-        -> (PieceMap [Block a], Maybe (Piece a))
-inserta = undefined
-
--}
diff --git a/src/Data/Torrent/Bitfield.hs b/src/Network/BitTorrent/Exchange/Bitfield.hs
index b65f058b..eca11d83 100644
--- a/src/Data/Torrent/Bitfield.hs
+++ b/src/Network/BitTorrent/Exchange/Bitfield.hs
@@ -27,7 +27,7 @@
 {-# LANGUAGE CPP #-}
 {-# LANGUAGE BangPatterns #-}
 {-# LANGUAGE RecordWildCards #-}
-module Data.Torrent.Bitfield
+module Network.BitTorrent.Exchange.Bitfield
        ( -- * Bitfield
          PieceIx
        , PieceCount
@@ -43,8 +43,8 @@ module Data.Torrent.Bitfield
 
          -- * Query
          -- ** Cardinality
-       , Data.Torrent.Bitfield.null
-       , Data.Torrent.Bitfield.full
+       , Network.BitTorrent.Exchange.Bitfield.null
+       , Network.BitTorrent.Exchange.Bitfield.full
        , haveCount
        , totalCount
        , completeness
@@ -75,6 +75,17 @@ module Data.Torrent.Bitfield
          -- * Serialization
        , fromBitmap
        , toBitmap
+
+         -- * Piece selection
+       , Selector
+       , selector
+       , strategyClass
+
+       , strictFirst
+       , strictLast
+       , rarestFirst
+       , randomFirst
+       , endGame
        ) where
 
 import Control.Monad
@@ -92,7 +103,7 @@ import           Data.List (foldl')
 import           Data.Monoid
 import           Data.Ratio
 
-import Data.Torrent.Piece
+import Data.Torrent
 
 -- TODO cache some operations
 
@@ -322,3 +333,66 @@ toBitmap Bitfield {..} = {-# SCC toBitmap #-} Lazy.fromChunks [intsetBM, alignme
     byteSize  = bfSize `div` 8 + if bfSize `mod` 8 == 0 then 0 else 1
     alignment = B.replicate (byteSize - B.length intsetBM) 0
     intsetBM  = S.toByteString bfSet
+
+{-----------------------------------------------------------------------
+--  Piece selection
+-----------------------------------------------------------------------}
+
+type Selector =  Bitfield      -- ^ Indices of client /have/ pieces.
+             ->  Bitfield      -- ^ Indices of peer /have/ pieces.
+             -> [Bitfield]     -- ^ Indices of other peers /have/ pieces.
+             -> Maybe PieceIx  -- ^ Zero-based index of piece to request
+                               --   to, if any.
+
+selector :: Selector       -- ^ Selector to use at the start.
+         -> Ratio PieceCount
+         -> Selector       -- ^ Selector to use after the client have
+                           -- the C pieces.
+         -> Selector       -- ^ Selector that changes behaviour based
+                           -- on completeness.
+selector start pt ready   h a xs =
+  case strategyClass pt h of
+    SCBeginning -> start h a xs
+    SCReady     -> ready h a xs
+    SCEnd       -> endGame h a xs
+
+data StartegyClass
+  = SCBeginning
+  | SCReady
+  | SCEnd
+    deriving (Show, Eq, Ord, Enum, Bounded)
+
+
+strategyClass :: Ratio PieceCount -> Bitfield -> StartegyClass
+strategyClass threshold = classify . completeness
+  where
+    classify c
+      |        c < threshold       = SCBeginning
+      | c + 1 % numerator c < 1    = SCReady
+    -- FIXME numerator have is not total count
+      |          otherwise         = SCEnd
+
+
+-- | Select the first available piece.
+strictFirst :: Selector
+strictFirst h a _ = Just $ findMin (difference a h)
+
+-- | Select the last available piece.
+strictLast :: Selector
+strictLast h a _ = Just $ findMax (difference a h)
+
+-- |
+rarestFirst :: Selector
+rarestFirst h a xs = rarest (map (intersection want) xs)
+  where
+    want = difference h a
+
+-- | In average random first is faster than rarest first strategy but
+--    only if all pieces are available.
+randomFirst :: Selector
+randomFirst = do
+--  randomIO
+  error "randomFirst"
+
+endGame :: Selector
+endGame = strictLast
diff --git a/src/Network/BitTorrent/Exchange/Block.hs b/src/Network/BitTorrent/Exchange/Block.hs
index 16c124e9..ccc7a0a9 100644
--- a/src/Network/BitTorrent/Exchange/Block.hs
+++ b/src/Network/BitTorrent/Exchange/Block.hs
@@ -69,7 +69,7 @@ import Numeric
 import Text.PrettyPrint as PP hiding ((<>))
 import Text.PrettyPrint.Class
 
-import Data.Torrent.Piece
+import Data.Torrent
 
 {-----------------------------------------------------------------------
 --  Block attributes
diff --git a/src/Network/BitTorrent/Exchange/Connection.hs b/src/Network/BitTorrent/Exchange/Connection.hs
index fd9022da..2d5f39bf 100644
--- a/src/Network/BitTorrent/Exchange/Connection.hs
+++ b/src/Network/BitTorrent/Exchange/Connection.hs
@@ -112,6 +112,7 @@ import Control.Concurrent hiding (yield)
 import Control.Exception
 import Control.Monad.Reader
 import Control.Monad.State
+import Control.Monad.Trans.Resource
 import Control.Lens
 import Data.ByteString as BS
 import Data.ByteString.Lazy as BSL
@@ -135,10 +136,10 @@ import Text.Show.Functions ()
 import System.Log.FastLogger (ToLogStr(..))
 import System.Timeout
 
-import Data.Torrent.Bitfield as BF
-import Data.Torrent.InfoHash
-import Network.BitTorrent.Core
-import Network.BitTorrent.Exchange.Message as Msg
+import Data.Torrent
+import Network.BitTorrent.Address
+import Network.BitTorrent.Exchange.Bitfield as BF
+import Network.BitTorrent.Exchange.Message  as Msg
 
 -- TODO handle port message?
 -- TODO handle limits?
diff --git a/src/Network/BitTorrent/Exchange/Download.hs b/src/Network/BitTorrent/Exchange/Download.hs
new file mode 100644
index 00000000..9a6b5f91
--- /dev/null
+++ b/src/Network/BitTorrent/Exchange/Download.hs
@@ -0,0 +1,295 @@
+-- |
+--   Copyright   :  (c) Sam Truzjan 2013
+--   License     :  BSD3
+--   Maintainer  :  pxqr.sta@gmail.com
+--   Stability   :  experimental
+--   Portability :  portable
+--
+--
+--
+{-# LANGUAGE FlexibleInstances      #-}
+{-# LANGUAGE MultiParamTypeClasses  #-}
+{-# LANGUAGE FunctionalDependencies #-}
+{-# LANGUAGE TemplateHaskell        #-}
+module Network.BitTorrent.Exchange.Download
+       ( -- * Downloading
+         Download (..)
+       , Updates
+       , runDownloadUpdates
+
+         -- ** Metadata
+         -- $metadata-download
+       , MetadataDownload
+       , metadataDownload
+
+         -- ** Content
+         -- $content-download
+       , ContentDownload
+       , contentDownload
+       ) where
+
+import Control.Applicative
+import Control.Concurrent
+import Control.Lens
+import Control.Monad.State
+import Data.BEncode as BE
+import Data.ByteString as BS
+import Data.ByteString.Lazy as BL
+import Data.Default
+import Data.List as L
+import Data.Maybe
+import Data.Map as M
+import Data.Tuple
+
+import Data.Torrent as Torrent
+import Network.BitTorrent.Address
+import Network.BitTorrent.Exchange.Bitfield as BF
+import Network.BitTorrent.Exchange.Block    as Block
+import Network.BitTorrent.Exchange.Message  as Msg
+import System.Torrent.Storage (Storage, writePiece)
+
+
+{-----------------------------------------------------------------------
+--  Class
+-----------------------------------------------------------------------}
+
+type Updates s a = StateT s IO a
+
+runDownloadUpdates :: MVar s -> Updates s a -> IO a
+runDownloadUpdates var m = modifyMVar var (fmap swap . runStateT m)
+
+class Download s chunk | s -> chunk where
+  scheduleBlocks :: Int -> PeerAddr IP -> Bitfield -> Updates s [BlockIx]
+
+  -- |
+  scheduleBlock  :: PeerAddr IP -> Bitfield -> Updates s (Maybe BlockIx)
+  scheduleBlock addr bf = listToMaybe <$> scheduleBlocks 1 addr bf
+
+  -- | Get number of sent requests to this peer.
+  getRequestQueueLength :: PeerAddr IP -> Updates s Int
+
+  -- | Remove all pending block requests to the remote peer. May be used
+  -- when:
+  --
+  --     * a peer closes connection;
+  --
+  --     * remote peer choked this peer;
+  --
+  --     * timeout expired.
+  --
+  resetPending :: PeerAddr IP -> Updates s ()
+
+  -- | MAY write to storage, if a new piece have been completed.
+  --
+  --  You should check if a returned by peer block is actually have
+  -- been requested and in-flight. This is needed to avoid "I send
+  -- random corrupted block" attacks.
+  pushBlock :: PeerAddr IP -> chunk -> Updates s (Maybe Bool)
+
+{-----------------------------------------------------------------------
+--  Metadata download
+-----------------------------------------------------------------------}
+-- $metadata-download
+-- TODO
+
+data MetadataDownload = MetadataDownload
+  { _pendingPieces :: [(PeerAddr IP, PieceIx)]
+  , _bucket        :: Bucket
+  , _topic         :: InfoHash
+  }
+
+makeLenses ''MetadataDownload
+
+-- | Create a new scheduler for infodict of the given size.
+metadataDownload :: Int -> InfoHash -> MetadataDownload
+metadataDownload ps = MetadataDownload [] (Block.empty ps)
+
+instance Default MetadataDownload where
+  def = error "instance Default MetadataDownload"
+
+--cancelPending :: PieceIx -> Updates ()
+cancelPending pix = pendingPieces %= L.filter ((pix ==) . snd)
+
+instance Download MetadataDownload (Piece BS.ByteString) where
+  scheduleBlock addr bf = do
+    bkt  <- use bucket
+    case spans metadataPieceSize bkt of
+      []              -> return Nothing
+      ((off, _ ) : _) -> do
+        let pix = off `div` metadataPieceSize
+        pendingPieces %= ((addr, pix) :)
+        return (Just (BlockIx pix 0 metadataPieceSize))
+
+  resetPending addr = pendingPieces %= L.filter ((addr ==) . fst)
+
+  pushBlock addr Torrent.Piece {..} = do
+    p    <- use pendingPieces
+    when ((addr, pieceIndex) `L.notElem` p) $
+      error "not requested"
+    cancelPending pieceIndex
+
+    bucket %= Block.insert (metadataPieceSize * pieceIndex) pieceData
+    b <- use bucket
+    case toPiece b of
+      Nothing     -> return Nothing
+      Just chunks -> do
+          t <- use topic
+          case parseInfoDict (BL.toStrict chunks) t of
+            Right x -> do
+                pendingPieces .= []
+                return undefined -- (Just x)
+            Left  e -> do
+                pendingPieces .= []
+                bucket .= Block.empty (Block.size b)
+                return undefined -- Nothing
+   where
+      -- todo use incremental parsing to avoid BS.concat call
+      parseInfoDict :: BS.ByteString -> InfoHash -> Result InfoDict
+      parseInfoDict chunk topic =
+        case BE.decode chunk of
+          Right (infodict @ InfoDict {..})
+            | topic == idInfoHash -> return infodict
+            |      otherwise      -> Left "broken infodict"
+          Left err -> Left $ "unable to parse infodict " ++ err
+
+{-----------------------------------------------------------------------
+--  Content download
+-----------------------------------------------------------------------}
+-- $content-download
+--
+--  A block can have one of the following status:
+--
+--     1) /not allowed/: Piece is not in download set.
+--
+--     2) /waiting/: (allowed?) Block have been allowed to download,
+--     but /this/ peer did not send any 'Request' message for this
+--     block. To allow some piece use
+--     'Network.BitTorrent.Exchange.Selector' and then 'allowedSet'
+--     and 'allowPiece'.
+--
+--     3) /inflight/: (pending?) Block have been requested but
+--     /remote/ peer did not send any 'Piece' message for this block.
+--     Related functions 'markInflight'
+--
+--     4) /pending/: (stalled?) Block have have been downloaded
+--     Related functions 'insertBlock'.
+--
+--   Piece status:
+--
+--     1) /assembled/: (downloaded?) All blocks in piece have been
+--     downloaded but the piece did not verified yet.
+--
+--       * Valid: go to completed;
+--
+--       * Invalid: go to waiting.
+--
+--     2) /corrupted/:
+--
+--     3) /downloaded/: (verified?) A piece have been successfully
+--     verified via the hash. Usually the piece should be stored to
+--     the 'System.Torrent.Storage' and /this/ peer should send 'Have'
+--     messages to the /remote/ peers.
+--
+
+data PieceEntry = PieceEntry
+  { pending :: [(PeerAddr IP, BlockIx)]
+  , stalled :: Bucket
+  }
+
+pieceEntry :: PieceSize -> PieceEntry
+pieceEntry s = PieceEntry [] (Block.empty s)
+
+isEmpty :: PieceEntry -> Bool
+isEmpty PieceEntry {..} = L.null pending && Block.null stalled
+
+_holes :: PieceIx -> PieceEntry -> [BlockIx]
+_holes pix PieceEntry {..} = fmap mkBlockIx (spans defaultTransferSize stalled)
+  where
+    mkBlockIx (off, sz) = BlockIx pix off sz
+
+data ContentDownload = ContentDownload
+  { inprogress     :: !(Map PieceIx PieceEntry)
+  , bitfield       :: !Bitfield
+  , pieceSize      :: !PieceSize
+  , contentStorage ::  Storage
+  }
+
+contentDownload :: Bitfield -> PieceSize -> Storage -> ContentDownload
+contentDownload = ContentDownload M.empty
+
+--modifyEntry :: PieceIx -> (PieceEntry -> PieceEntry) -> DownloadUpdates ()
+modifyEntry pix f = modify $ \ s @ ContentDownload {..} -> s
+    { inprogress = alter (g pieceSize) pix inprogress }
+  where
+    g s = h . f . fromMaybe (pieceEntry s)
+    h e
+      | isEmpty e = Nothing
+      | otherwise = Just e
+
+instance Download ContentDownload (Block BL.ByteString) where
+  scheduleBlocks n addr maskBF = do
+    ContentDownload {..} <- get
+    let wantPieces = maskBF `BF.difference` bitfield
+    let wantBlocks = L.concat $ M.elems $ M.mapWithKey _holes $
+                     M.filterWithKey (\ pix _ -> pix `BF.member` wantPieces)
+                      inprogress
+
+    bixs <- if L.null wantBlocks
+      then do
+        mpix <- choosePiece wantPieces
+        case mpix of -- TODO return 'n' blocks
+          Nothing  -> return []
+          Just pix -> return [leadingBlock pix defaultTransferSize]
+      else chooseBlocks wantBlocks n
+
+    forM_ bixs $ \ bix -> do
+      modifyEntry (ixPiece bix) $ \ e @ PieceEntry {..} -> e
+        { pending = (addr, bix) : pending }
+
+    return bixs
+    where
+      -- TODO choose block nearest to pending or stalled sets to reduce disk
+      -- seeks on remote machines
+      --chooseBlocks :: [BlockIx] -> Int -> DownloadUpdates [BlockIx]
+      chooseBlocks xs n = return (L.take n xs)
+
+      -- TODO use selection strategies from Exchange.Selector
+      --choosePiece :: Bitfield -> DownloadUpdates (Maybe PieceIx)
+      choosePiece bf
+        | BF.null bf = return $ Nothing
+        | otherwise  = return $ Just $ BF.findMin bf
+
+  getRequestQueueLength addr = do
+    m <- gets (M.map (L.filter ((==) addr . fst) . pending) . inprogress)
+    return $ L.sum $ L.map L.length $ M.elems m
+
+  resetPending addr = modify $ \ s -> s { inprogress = reset (inprogress s) }
+    where
+      reset = fmap $ \ e -> e
+            { pending = L.filter (not . (==) addr . fst) (pending e) }
+
+  pushBlock addr blk @ Block {..} = do
+    mpe <- gets (M.lookup blkPiece . inprogress)
+    case mpe of
+      Nothing -> return Nothing
+      Just (pe @ PieceEntry {..})
+        | blockIx blk `L.notElem` fmap snd pending -> return Nothing
+        |             otherwise                    -> do
+         let bkt' = Block.insertLazy blkOffset blkData stalled
+         case toPiece bkt' of
+           Nothing        -> do
+             modifyEntry blkPiece $ \ e @ PieceEntry {..} -> e
+               { pending = L.filter ((==) (blockIx blk) . snd) pending
+               , stalled = bkt'
+               }
+             return (Just False)
+
+           Just pieceData -> do
+             -- TODO verify
+             storage <- gets contentStorage
+             liftIO $ writePiece (Torrent.Piece blkPiece pieceData) storage
+             modify $ \ s @ ContentDownload {..} -> s
+               { inprogress =  M.delete blkPiece inprogress
+               , bitfield   = BF.insert blkPiece bitfield
+               }
+             return (Just True)
diff --git a/src/Network/BitTorrent/Exchange/Manager.hs b/src/Network/BitTorrent/Exchange/Manager.hs
index b9aaa818..54727805 100644
--- a/src/Network/BitTorrent/Exchange/Manager.hs
+++ b/src/Network/BitTorrent/Exchange/Manager.hs
@@ -12,8 +12,8 @@ import Control.Monad
 import Data.Default
 import Network.Socket
 
-import Data.Torrent.InfoHash
-import Network.BitTorrent.Core
+import Data.Torrent
+import Network.BitTorrent.Address
 import Network.BitTorrent.Exchange.Connection hiding (Options)
 import Network.BitTorrent.Exchange.Session
 
diff --git a/src/Network/BitTorrent/Exchange/Message.hs b/src/Network/BitTorrent/Exchange/Message.hs
index d8873f95..f8b76186 100644
--- a/src/Network/BitTorrent/Exchange/Message.hs
+++ b/src/Network/BitTorrent/Exchange/Message.hs
@@ -117,10 +117,10 @@ import Network.Socket hiding (KeepAlive)
 import Text.PrettyPrint as PP hiding ((<>))
 import Text.PrettyPrint.Class
 
-import Data.Torrent.Bitfield
-import Data.Torrent.InfoHash
-import qualified Data.Torrent.Piece as P
-import Network.BitTorrent.Core
+import Data.Torrent hiding (Piece (..))
+import qualified Data.Torrent as P (Piece (..))
+import Network.BitTorrent.Address
+import Network.BitTorrent.Exchange.Bitfield
 import Network.BitTorrent.Exchange.Block
 
 {-----------------------------------------------------------------------
@@ -864,7 +864,7 @@ instance PeerMessage ExtendedMetadata where
 
 -- | All 'Piece's in 'MetadataData' messages MUST have size equal to
 -- this value. The last trailing piece can be shorter.
-metadataPieceSize :: P.PieceSize
+metadataPieceSize :: PieceSize
 metadataPieceSize = 16 * 1024
 
 isLastPiece :: P.Piece a -> Int -> Bool
@@ -877,8 +877,8 @@ isLastPiece P.Piece {..} total = succ pieceIndex == pcnt
 -- length; otherwise serialization MUST fail.
 isValidPiece :: P.Piece BL.ByteString -> Int -> Bool
 isValidPiece p @ P.Piece {..} total
-  | isLastPiece p total = P.pieceSize p <= metadataPieceSize
-  |       otherwise     = P.pieceSize p == metadataPieceSize
+  | isLastPiece p total = pieceSize p <= metadataPieceSize
+  |       otherwise     = pieceSize p == metadataPieceSize
 
 setMetadataPayload :: BS.ByteString -> ExtendedMetadata -> ExtendedMetadata
 setMetadataPayload bs (MetadataData (P.Piece pix _) t) =
diff --git a/src/Network/BitTorrent/Exchange/Selection.hs b/src/Network/BitTorrent/Exchange/Selection.hs
deleted file mode 100644
index 2724fabc..00000000
--- a/src/Network/BitTorrent/Exchange/Selection.hs
+++ /dev/null
@@ -1,85 +0,0 @@
--- |
---   Copyright   :  (c) Sam Truzjan 2013
---   License     :  BSD3
---   Maintainer  :  pxqr.sta@gmail.com
---   Stability   :  experimental
---   Portability :  portable
---
---   Piece selection algorithms.
---
-module Network.BitTorrent.Exchange.Selection
-       ( -- * Selection
-         Selector
-       , selector
-       , strategyClass
-
-       , strictFirst
-       , strictLast
-       , rarestFirst
-       , randomFirst
-       , endGame
-       ) where
-
-import Data.Ratio
-
-import Data.Torrent.Bitfield
-
-
-type Selector =  Bitfield      -- ^ Indices of client /have/ pieces.
-             ->  Bitfield      -- ^ Indices of peer /have/ pieces.
-             -> [Bitfield]     -- ^ Indices of other peers /have/ pieces.
-             -> Maybe PieceIx  -- ^ Zero-based index of piece to request
-                               --   to, if any.
-
-selector :: Selector       -- ^ Selector to use at the start.
-         -> Ratio PieceCount
-         -> Selector       -- ^ Selector to use after the client have
-                           -- the C pieces.
-         -> Selector       -- ^ Selector that changes behaviour based
-                           -- on completeness.
-selector start pt ready   h a xs =
-  case strategyClass pt h of
-    SCBeginning -> start h a xs
-    SCReady     -> ready h a xs
-    SCEnd       -> endGame h a xs
-
-data StartegyClass
-  = SCBeginning
-  | SCReady
-  | SCEnd
-    deriving (Show, Eq, Ord, Enum, Bounded)
-
-
-strategyClass :: Ratio PieceCount -> Bitfield -> StartegyClass
-strategyClass threshold = classify . completeness
-  where
-    classify c
-      |        c < threshold       = SCBeginning
-      | c + 1 % numerator c < 1    = SCReady
-    -- FIXME numerator have is not total count
-      |          otherwise         = SCEnd
-
-
--- | Select the first available piece.
-strictFirst :: Selector
-strictFirst h a _ = Just $ findMin (difference a h)
-
--- | Select the last available piece.
-strictLast :: Selector
-strictLast h a _ = Just $ findMax (difference a h)
-
--- |
-rarestFirst :: Selector
-rarestFirst h a xs = rarest (map (intersection want) xs)
-  where
-    want = difference h a
-
--- | In average random first is faster than rarest first strategy but
---    only if all pieces are available.
-randomFirst :: Selector
-randomFirst = do
---  randomIO
-  error "randomFirst"
-
-endGame :: Selector
-endGame = strictLast
diff --git a/src/Network/BitTorrent/Exchange/Session.hs b/src/Network/BitTorrent/Exchange/Session.hs
index 6f480ce4..30b7ed0e 100644
--- a/src/Network/BitTorrent/Exchange/Session.hs
+++ b/src/Network/BitTorrent/Exchange/Session.hs
@@ -45,18 +45,14 @@ import Text.PrettyPrint.Class
 import System.Log.FastLogger (LogStr, ToLogStr (..))
 
 import Data.BEncode as BE
-import Data.Torrent (InfoDict (..))
-import Data.Torrent.Bitfield as BF
-import Data.Torrent.InfoHash
-import Data.Torrent.Piece
-import qualified Data.Torrent.Piece as Torrent (Piece ())
+import Data.Torrent as Torrent
 import Network.BitTorrent.Internal.Types
-import Network.BitTorrent.Core
+import Network.BitTorrent.Address
+import Network.BitTorrent.Exchange.Bitfield as BF
 import Network.BitTorrent.Exchange.Block   as Block
 import Network.BitTorrent.Exchange.Connection
+import Network.BitTorrent.Exchange.Download as D
 import Network.BitTorrent.Exchange.Message as Message
-import Network.BitTorrent.Exchange.Session.Metadata as Metadata
-import Network.BitTorrent.Exchange.Session.Status   as SS
 import System.Torrent.Storage
 
 {-----------------------------------------------------------------------
@@ -93,13 +89,13 @@ type LogFun = Loc -> LogSource -> LogLevel -> LogStr -> IO ()
 
 data SessionState
   = WaitingMetadata
-    { metadataDownload  :: MVar Metadata.Status
+    { metadataDownload  :: MVar MetadataDownload
     , metadataCompleted :: MVar InfoDict -- ^ used to unblock waiters
     , contentRootPath   :: FilePath
     }
   | HavingMetadata
     { metadataCache     :: Cached InfoDict
-    , contentDownload   :: MVar SessionStatus
+    , contentDownload   :: MVar ContentDownload
     , contentStorage    :: Storage
     }
 
@@ -108,8 +104,9 @@ newSessionState rootPath (Left  ih  ) = do
   WaitingMetadata <$> newMVar def <*> newEmptyMVar <*> pure rootPath
 newSessionState rootPath (Right dict) = do
   storage     <- openInfoDict ReadWriteEx rootPath dict
-  download    <- newMVar $ sessionStatus (BF.haveNone (totalPieces storage))
-                                        (piPieceLength (idPieceInfo dict))
+  download    <- newMVar $ D.contentDownload (BF.haveNone (totalPieces storage))
+                                           (piPieceLength (idPieceInfo dict))
+                                           storage
   return $ HavingMetadata (cache dict) download storage
 
 closeSessionState :: SessionState -> IO ()
@@ -119,8 +116,9 @@ closeSessionState HavingMetadata  {..} = close contentStorage
 haveMetadata :: InfoDict -> SessionState -> IO SessionState
 haveMetadata dict WaitingMetadata {..} = do
   storage     <- openInfoDict ReadWriteEx contentRootPath dict
-  download    <- newMVar $ sessionStatus (BF.haveNone (totalPieces storage))
-                                        (piPieceLength (idPieceInfo dict))
+  download    <- newMVar $ D.contentDownload (BF.haveNone (totalPieces storage))
+                                           (piPieceLength (idPieceInfo dict))
+                                            storage
   return HavingMetadata
     { metadataCache   = cache dict
     , contentDownload = download
diff --git a/src/Network/BitTorrent/Exchange/Session/Metadata.hs b/src/Network/BitTorrent/Exchange/Session/Metadata.hs
deleted file mode 100644
index 79156e2e..00000000
--- a/src/Network/BitTorrent/Exchange/Session/Metadata.hs
+++ /dev/null
@@ -1,104 +0,0 @@
-{-# LANGUAGE TemplateHaskell #-}
-module Network.BitTorrent.Exchange.Session.Metadata
-       ( -- * Transfer state
-         Status
-       , nullStatus
-
-         -- * State updates
-       , Updates
-       , runUpdates
-
-         -- * Piece transfer control
-       , scheduleBlock
-       , resetPending
-       , cancelPending
-       , pushBlock
-       ) where
-
-import Control.Concurrent
-import Control.Lens
-import Control.Monad.Reader
-import Control.Monad.State
-import Data.ByteString as BS
-import Data.ByteString.Lazy as BL
-import Data.Default
-import Data.List as L
-import Data.Tuple
-
-import Data.BEncode as BE
-import Data.Torrent
-import Data.Torrent.InfoHash
-import Data.Torrent.Piece as Torrent
-import Network.BitTorrent.Core
-import Network.BitTorrent.Exchange.Block   as Block
-import Network.BitTorrent.Exchange.Message as Message hiding (Status)
-
-
--- | Current transfer status.
-data Status = Status
-  { _pending :: [(PeerAddr IP, PieceIx)]
-  , _bucket  :: Bucket
-  }
-
-makeLenses ''Status
-
-instance Default Status where
-  def = error "default status"
-
--- | Create a new scheduler for infodict of the given size.
-nullStatus :: Int -> Status
-nullStatus ps = Status [] (Block.empty ps)
-
-type Updates = ReaderT (PeerAddr IP) (State Status)
-
-runUpdates :: MVar Status -> PeerAddr IP -> Updates a -> IO a
-runUpdates v a m = modifyMVar v (return . swap . runState (runReaderT m a))
-
-scheduleBlock :: Updates (Maybe PieceIx)
-scheduleBlock = do
-  addr <- ask
-  bkt  <- use bucket
-  case spans metadataPieceSize bkt of
-    []              -> return Nothing
-    ((off, _ ) : _) -> do
-      let pix = off `div` metadataPieceSize
-      pending %= ((addr, pix) :)
-      return (Just pix)
-
-cancelPending :: PieceIx -> Updates ()
-cancelPending pix = pending %= L.filter ((pix ==) . snd)
-
-resetPending :: Updates ()
-resetPending = do
-  addr <- ask
-  pending %= L.filter ((addr ==) . fst)
-
-parseInfoDict :: BS.ByteString -> InfoHash -> Result InfoDict
-parseInfoDict chunk topic =
-  case BE.decode chunk of
-    Right (infodict @ InfoDict {..})
-      | topic == idInfoHash -> return infodict
-      |      otherwise      -> Left "broken infodict"
-    Left err -> Left $ "unable to parse infodict " ++ err
-
--- todo use incremental parsing to avoid BS.concat call
-pushBlock :: Torrent.Piece BS.ByteString -> InfoHash -> Updates (Maybe InfoDict)
-pushBlock Torrent.Piece {..} topic = do
-  addr <- ask
-  p    <- use pending
-  when ((addr, pieceIndex) `L.notElem` p) $ error "not requested"
-  cancelPending pieceIndex
-
-  bucket %= Block.insert (metadataPieceSize * pieceIndex) pieceData
-  b <- use bucket
-  case toPiece b of
-    Nothing     -> return Nothing
-    Just chunks ->
-        case parseInfoDict (BL.toStrict chunks) topic of
-          Right x -> do
-              pending .= []
-              return (Just x)
-          Left  e -> do
-              pending .= []
-              bucket  .= Block.empty (Block.size b)
-              return Nothing
diff --git a/src/Network/BitTorrent/Exchange/Session/Status.hs b/src/Network/BitTorrent/Exchange/Session/Status.hs
deleted file mode 100644
index 565c3bf3..00000000
--- a/src/Network/BitTorrent/Exchange/Session/Status.hs
+++ /dev/null
@@ -1,175 +0,0 @@
-module Network.BitTorrent.Exchange.Session.Status
-       ( -- * Environment
-         StatusUpdates
-       , runStatusUpdates
-
-         -- * Status
-       , SessionStatus
-       , sessionStatus
-
-         -- * Query
-       , getBitfield
-       , getRequestQueueLength
-
-         -- * Control
-       , scheduleBlocks
-       , resetPending
-       , pushBlock
-       ) where
-
-import Control.Applicative
-import Control.Concurrent
-import Control.Monad.State
-import Data.ByteString.Lazy as BL
-import Data.Default
-import Data.List as L
-import Data.Maybe
-import Data.Map as M
-import Data.Set as S
-import Data.Tuple
-
-import Data.Torrent.Piece
-import Data.Torrent.Bitfield as BF
-import Network.BitTorrent.Core
-import Network.BitTorrent.Exchange.Block as Block
-import System.Torrent.Storage (Storage, writePiece)
-
-
-{-----------------------------------------------------------------------
---  Piece entry
------------------------------------------------------------------------}
-
-data PieceEntry = PieceEntry
-  { pending :: [(PeerAddr IP, BlockIx)]
-  , stalled :: Bucket
-  }
-
-pieceEntry :: PieceSize -> PieceEntry
-pieceEntry s = PieceEntry [] (Block.empty s)
-
-isEmpty :: PieceEntry -> Bool
-isEmpty PieceEntry {..} = L.null pending && Block.null stalled
-
-holes :: PieceIx -> PieceEntry -> [BlockIx]
-holes pix PieceEntry {..} = fmap mkBlockIx (spans defaultTransferSize stalled)
-  where
-    mkBlockIx (off, sz) = BlockIx pix off sz
-
-{-----------------------------------------------------------------------
---  Session status
------------------------------------------------------------------------}
-
-data SessionStatus = SessionStatus
-  { inprogress :: !(Map PieceIx PieceEntry)
-  , bitfield   :: !Bitfield
-  , pieceSize  :: !PieceSize
-  }
-
-sessionStatus :: Bitfield -> PieceSize -> SessionStatus
-sessionStatus bf ps = SessionStatus
-  { inprogress = M.empty
-  , bitfield   = bf
-  , pieceSize  = ps
-  }
-
-type StatusUpdates a = StateT SessionStatus IO a
-
--- |
-runStatusUpdates :: MVar SessionStatus -> StatusUpdates a -> IO a
-runStatusUpdates var m = modifyMVar var (fmap swap . runStateT m)
-
-getBitfield :: MVar SessionStatus -> IO Bitfield
-getBitfield var = bitfield <$> readMVar var
-
-getRequestQueueLength :: PeerAddr IP -> StatusUpdates Int
-getRequestQueueLength addr = do
-  m <- gets (M.elems . M.map (L.filter ((==) addr . fst) . pending) . inprogress)
-  return $ L.sum $ L.map L.length m
-
-modifyEntry :: PieceIx -> (PieceEntry -> PieceEntry) -> StatusUpdates ()
-modifyEntry pix f = modify $ \ s @ SessionStatus {..} -> s
-    { inprogress = alter (g pieceSize) pix inprogress }
-  where
-    g s = h . f . fromMaybe (pieceEntry s)
-    h e
-      | isEmpty e = Nothing
-      | otherwise = Just e
-
-{-----------------------------------------------------------------------
---  Piece download
------------------------------------------------------------------------}
-
--- TODO choose block nearest to pending or stalled sets to reduce disk
--- seeks on remote machines
-chooseBlocks :: [BlockIx] -> Int -> StatusUpdates [BlockIx]
-chooseBlocks xs n = return (L.take n xs)
-
--- TODO use selection strategies from Exchange.Selector
-choosePiece :: Bitfield -> StatusUpdates (Maybe PieceIx)
-choosePiece bf
-  | BF.null bf = return $ Nothing
-  | otherwise  = return $ Just $ BF.findMin bf
-
-scheduleBlocks :: PeerAddr IP -> Bitfield -> Int -> StatusUpdates [BlockIx]
-scheduleBlocks addr maskBF n = do
-  SessionStatus {..} <- get
-  let wantPieces = maskBF `BF.difference` bitfield
-  let wantBlocks = L.concat $ M.elems $ M.mapWithKey holes $
-                   M.filterWithKey (\ pix _ -> pix `BF.member` wantPieces) inprogress
-
-  bixs <- if L.null wantBlocks
-    then do
-      mpix <- choosePiece wantPieces
-      case mpix of -- TODO return 'n' blocks
-        Nothing  -> return []
-        Just pix -> return [leadingBlock pix defaultTransferSize]
-    else chooseBlocks wantBlocks n
-
-  forM_ bixs $ \ bix -> do
-    modifyEntry (ixPiece bix) $ \ e @ PieceEntry {..} -> e
-      { pending = (addr, bix) : pending }
-
-  return bixs
-
-
--- | Remove all pending block requests to the remote peer. May be used
--- when:
---
---     * a peer closes connection;
---
---     * remote peer choked this peer;
---
---     * timeout expired.
---
-resetPending :: PeerAddr IP -> StatusUpdates ()
-resetPending addr = modify $ \ s -> s { inprogress = reset (inprogress s) }
-  where
-    reset = fmap $ \ e -> e
-            { pending = L.filter (not . (==) addr . fst) (pending e) }
-
--- | MAY write to storage, if a new piece have been completed.
-pushBlock :: Block BL.ByteString -> Storage -> StatusUpdates (Maybe Bool)
-pushBlock blk @ Block {..} storage = do
-  mpe <- gets (M.lookup blkPiece . inprogress)
-  case mpe of
-    Nothing -> return Nothing
-    Just (pe @ PieceEntry {..})
-      | blockIx blk `L.notElem` fmap snd pending -> return Nothing
-      |             otherwise                    -> do
-       let bkt' = Block.insertLazy blkOffset blkData stalled
-       case toPiece bkt' of
-         Nothing        -> do
-           modifyEntry blkPiece $ \ e @ PieceEntry {..} -> e
-             { pending = L.filter ((==) (blockIx blk) . snd) pending
-             , stalled = bkt'
-             }
-           return (Just False)
-
-         Just pieceData -> do
-           -- TODO verify
-           liftIO $ writePiece (Piece blkPiece pieceData) storage
-           modify $ \ s @ SessionStatus {..} -> s
-             { inprogress =  M.delete blkPiece inprogress
-             , bitfield   = BF.insert blkPiece bitfield
-             }
-           return (Just True)
diff --git a/src/Data/Torrent/Progress.hs b/src/Network/BitTorrent/Internal/Progress.hs
index 4719020a..9aff9935 100644
--- a/src/Data/Torrent/Progress.hs
+++ b/src/Network/BitTorrent/Internal/Progress.hs
@@ -13,7 +13,7 @@
 {-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE ViewPatterns    #-}
 {-# OPTIONS -fno-warn-orphans #-}
-module Data.Torrent.Progress
+module Network.BitTorrent.Internal.Progress
        ( -- * Progress
          Progress (..)
 
@@ -39,7 +39,6 @@ import Control.Lens hiding ((%=))
 import Data.ByteString.Lazy.Builder  as BS
 import Data.ByteString.Lazy.Builder.ASCII as BS
 import Data.Default
-import Data.List as L
 import Data.Monoid
 import Data.Serialize as S
 import Data.Ratio
diff --git a/src/Network/BitTorrent/Tracker/Message.hs b/src/Network/BitTorrent/Tracker/Message.hs
index cdc07af8..e4a41045 100644
--- a/src/Network/BitTorrent/Tracker/Message.hs
+++ b/src/Network/BitTorrent/Tracker/Message.hs
@@ -124,10 +124,9 @@ import Numeric
 import System.Entropy
 import Text.Read (readMaybe)
 
-import Data.Torrent.InfoHash
-import Data.Torrent.Progress
-import Network.BitTorrent.Core
-
+import Data.Torrent
+import Network.BitTorrent.Address
+import Network.BitTorrent.Internal.Progress
 
 {-----------------------------------------------------------------------
 --  Events
diff --git a/src/Network/BitTorrent/Tracker/RPC.hs b/src/Network/BitTorrent/Tracker/RPC.hs
index dc1bd4ec..6fd22b25 100644
--- a/src/Network/BitTorrent/Tracker/RPC.hs
+++ b/src/Network/BitTorrent/Tracker/RPC.hs
@@ -25,7 +25,7 @@ module Network.BitTorrent.Tracker.RPC
          -- * RPC
        , SAnnounceQuery (..)
        , RpcException (..)
-       , announce
+       , Network.BitTorrent.Tracker.RPC.announce
        , scrape
        ) where
 
@@ -36,9 +36,9 @@ import Network
 import Network.URI
 import Network.Socket (HostAddress)
 
-import           Data.Torrent.InfoHash
-import           Data.Torrent.Progress
-import           Network.BitTorrent.Core
+import           Data.Torrent
+import           Network.BitTorrent.Address
+import           Network.BitTorrent.Internal.Progress
 import           Network.BitTorrent.Tracker.Message
 import qualified Network.BitTorrent.Tracker.RPC.HTTP as HTTP
 import qualified Network.BitTorrent.Tracker.RPC.UDP  as UDP
diff --git a/src/Network/BitTorrent/Tracker/RPC/HTTP.hs b/src/Network/BitTorrent/Tracker/RPC/HTTP.hs
index 4a8e5f79..6e55eb04 100644
--- a/src/Network/BitTorrent/Tracker/RPC/HTTP.hs
+++ b/src/Network/BitTorrent/Tracker/RPC/HTTP.hs
@@ -47,8 +47,8 @@ import qualified Network.HTTP.Conduit as HTTP
 import           Network.HTTP.Types.Header (hUserAgent)
 import           Network.HTTP.Types.URI    (SimpleQuery, renderSimpleQuery)
 
-import Data.Torrent.InfoHash               (InfoHash)
-import Network.BitTorrent.Core.Fingerprint (libUserAgent)
+import Data.Torrent                        (InfoHash)
+import Network.BitTorrent.Address             (libUserAgent)
 import Network.BitTorrent.Tracker.Message hiding (Request, Response)
 
 {-----------------------------------------------------------------------
diff --git a/src/Network/BitTorrent/Tracker/Session.hs b/src/Network/BitTorrent/Tracker/Session.hs
index 560acf84..cef7d665 100644
--- a/src/Network/BitTorrent/Tracker/Session.hs
+++ b/src/Network/BitTorrent/Tracker/Session.hs
@@ -57,8 +57,8 @@ import Data.Time
 import Data.Traversable
 import Network.URI
 
-import Data.Torrent.InfoHash
-import Network.BitTorrent.Core
+import Data.Torrent
+import Network.BitTorrent.Address
 import Network.BitTorrent.Internal.Cache
 import Network.BitTorrent.Internal.Types
 import Network.BitTorrent.Tracker.List as TL
diff --git a/src/System/Torrent/FileMap.hs b/src/System/Torrent/FileMap.hs
index 80907a30..6e8d7f5a 100644
--- a/src/System/Torrent/FileMap.hs
+++ b/src/System/Torrent/FileMap.hs
@@ -34,7 +34,7 @@ import Data.Vector as V -- TODO use unboxed vector
 import Foreign
 import System.IO.MMap
 
-import Data.Torrent.Layout
+import Data.Torrent
 
 
 data FileEntry = FileEntry
diff --git a/src/System/Torrent/Storage.hs b/src/System/Torrent/Storage.hs
index 003a4e98..1d77e55d 100644
--- a/src/System/Torrent/Storage.hs
+++ b/src/System/Torrent/Storage.hs
@@ -56,9 +56,7 @@ import Data.Conduit.List as C
 import Data.Typeable
 
 import Data.Torrent
-import Data.Torrent.Bitfield as BF
-import Data.Torrent.Layout
-import Data.Torrent.Piece
+import Network.BitTorrent.Exchange.Bitfield as BF
 import System.Torrent.FileMap as FM
 
 
diff --git a/src/Data/Torrent/Tree.hs b/src/System/Torrent/Tree.hs
index 102f4dff..41cfb360 100644
--- a/src/Data/Torrent/Tree.hs
+++ b/src/System/Torrent/Tree.hs
@@ -10,7 +10,7 @@
 {-# LANGUAGE FlexibleInstances  #-}
 {-# LANGUAGE TemplateHaskell    #-}
 {-# LANGUAGE DeriveDataTypeable #-}
-module Data.Torrent.Tree
+module System.Torrent.Tree
        ( -- * Directory tree
          DirTree (..)
 
@@ -18,7 +18,7 @@ module Data.Torrent.Tree
        , build
 
          -- * Query
-       , Data.Torrent.Tree.lookup
+       , System.Torrent.Tree.lookup
        , lookupDir
        , fileNumber
        , dirNumber
@@ -31,7 +31,7 @@ import Data.List as L
 import Data.Map  as M
 import Data.Monoid
 
-import Data.Torrent.Layout
+import Data.Torrent
 
 
 -- | 'DirTree' is more convenient form of 'LayoutInfo'.
@@ -61,13 +61,13 @@ build MultiFile {..} = Dir $ M.singleton liDirName files
 lookup :: [FilePath] -> DirTree a -> Maybe (DirTree a)
 lookup []        t      = Just t
 lookup (p : ps) (Dir m) | Just subTree <- M.lookup (BC.pack p) m
-                        = Data.Torrent.Tree.lookup ps subTree
+                        = System.Torrent.Tree.lookup ps subTree
 lookup _         _      = Nothing
 
 -- | Lookup directory by path.
 lookupDir :: [FilePath] -> DirTree a -> Maybe [(ByteString, DirTree a)]
 lookupDir ps d = do
-  subTree <- Data.Torrent.Tree.lookup ps d
+  subTree <- System.Torrent.Tree.lookup ps d
   case subTree of
     File _  -> Nothing
     Dir  es -> Just $ M.toList es
diff --git a/tests/Config.hs b/tests/Config.hs
index 09e838cc..9ffb0d8c 100644
--- a/tests/Config.hs
+++ b/tests/Config.hs
@@ -33,7 +33,7 @@ import System.IO.Unsafe
 import Test.Hspec
 
 import Data.Torrent
-import Network.BitTorrent.Core (IP, PeerAddr (PeerAddr), genPeerId)
+import Network.BitTorrent.Address (IP, PeerAddr (PeerAddr), genPeerId)
 
 
 type ClientName = String
diff --git a/tests/Data/Torrent/InfoHashSpec.hs b/tests/Data/Torrent/InfoHashSpec.hs
deleted file mode 100644
index 06570ec9..00000000
--- a/tests/Data/Torrent/InfoHashSpec.hs
+++ /dev/null
@@ -1,40 +0,0 @@
-{-# OPTIONS -fno-warn-orphans #-}
-module Data.Torrent.InfoHashSpec (spec) where
-
-import Control.Applicative
-import Data.ByteString as BS
-import Data.Convertible
-import System.FilePath
-import Test.Hspec
-import Test.QuickCheck
-import Test.QuickCheck.Instances ()
-
-import Data.Torrent
-import Data.Torrent.InfoHash as IH
-
-
-instance Arbitrary InfoHash where
-  arbitrary = do
-    bs <- BS.pack <$> vectorOf 20 arbitrary
-    pure $ either (const (error "arbitrary infohash")) id $ safeConvert bs
-
-type TestPair = (FilePath, String)
-
--- TODO add a few more torrents here
-torrentList :: [TestPair]
-torrentList =
-  [ ( "res" </> "dapper-dvd-amd64.iso.torrent"
-    , "0221caf96aa3cb94f0f58d458e78b0fc344ad8bf")
-  ]
-
-infohashSpec :: (FilePath, String) -> Spec
-infohashSpec (filepath, expectedHash) = do
-  it ("should match " ++ filepath) $ do
-    torrent    <- fromFile filepath
-    let actualHash = show $ idInfoHash $ tInfoDict torrent
-    actualHash `shouldBe` expectedHash
-
-spec :: Spec
-spec = do
-  describe "info hash" $ do
-    mapM_ infohashSpec torrentList
diff --git a/tests/Data/Torrent/LayoutSpec.hs b/tests/Data/Torrent/LayoutSpec.hs
deleted file mode 100644
index d3966b3f..00000000
--- a/tests/Data/Torrent/LayoutSpec.hs
+++ /dev/null
@@ -1,30 +0,0 @@
-{-# LANGUAGE GeneralizedNewtypeDeriving #-}
-{-# LANGUAGE StandaloneDeriving         #-}
-module Data.Torrent.LayoutSpec (spec) where
-
-import Control.Applicative
-import Test.Hspec
-import Test.QuickCheck
-import System.Posix.Types
-
-import Data.Torrent.Layout
-
-
-instance Arbitrary COff where
-  arbitrary = fromIntegral <$> (arbitrary :: Gen Int)
-
-instance Arbitrary a => Arbitrary (FileInfo a) where
-  arbitrary = FileInfo <$> arbitrary <*> arbitrary <*> arbitrary
-
-instance Arbitrary LayoutInfo where
-  arbitrary = oneof
-    [ SingleFile <$> arbitrary
-    , MultiFile  <$> arbitrary <*> arbitrary
-    ]
-
-spec :: Spec
-spec = do
-  describe "accumPosition" $ do
-    it "" $ property $ \ p1 p2 p3 s1 s2 s3 ->
-      accumPositions [(p1, s1), (p2, s2), (p3, s3)]
-        `shouldBe`   [(p1, (0, s1)), (p2, (s1, s2)), (p3, (s1 + s2, s3))]
\ No newline at end of file
diff --git a/tests/Data/Torrent/MagnetSpec.hs b/tests/Data/Torrent/MagnetSpec.hs
deleted file mode 100644
index 13554455..00000000
--- a/tests/Data/Torrent/MagnetSpec.hs
+++ /dev/null
@@ -1,44 +0,0 @@
-{-# OPTIONS -fno-warn-orphans #-}
-module Data.Torrent.MagnetSpec (spec) where
-
-import Control.Applicative
-import Data.Maybe
-import Data.Monoid
-import Test.Hspec
-import Test.QuickCheck
-import Test.QuickCheck.Instances ()
-import Network.URI
-
-import Data.Torrent.Magnet
-import Data.Torrent.InfoHashSpec ()
-
-
-instance Arbitrary URIAuth where
-  arbitrary = URIAuth <$> arbitrary <*> arbitrary <*> arbitrary
-
-instance Arbitrary URI where
-  arbitrary
-    = pure $ fromJust $ parseURI "http://ietf.org/1737.txt?a=1&b=h#123"
-
-instance Arbitrary Magnet where
-  arbitrary = Magnet <$> arbitrary <*> arbitrary
-    <*> arbitrary <*> arbitrary <*> arbitrary <*> arbitrary
-    <*> arbitrary <*> arbitrary <*> pure mempty
-
-magnetEncoding :: Magnet -> IO ()
-magnetEncoding m = parseMagnet (renderMagnet m) `shouldBe` Just m
-
-spec :: Spec
-spec = do
-  describe "Magnet" $ do
-    it "properly encoded" $ property $ magnetEncoding
-
-    it "parse base32" $ do
-      let magnet = "magnet:?xt=urn:btih:CT76LXJDDCH5LS2TUHKH6EUJ3NYKX4Y6"
-      let ih = "CT76LXJDDCH5LS2TUHKH6EUJ3NYKX4Y6"
-      parseMagnet magnet `shouldBe` Just (nullMagnet ih)
-
-    it "parse base16" $ do
-      let magnet = "magnet:?xt=urn:btih:0123456789abcdef0123456789abcdef01234567"
-      let ih = "0123456789abcdef0123456789abcdef01234567"
-      parseMagnet magnet `shouldBe` Just (nullMagnet ih)
diff --git a/tests/Data/Torrent/MetainfoSpec.hs b/tests/Data/Torrent/MetainfoSpec.hs
deleted file mode 100644
index 369c5e0f..00000000
--- a/tests/Data/Torrent/MetainfoSpec.hs
+++ /dev/null
@@ -1,80 +0,0 @@
-{-# LANGUAGE TypeSynonymInstances #-}
-{-# OPTIONS -fno-warn-orphans #-}
-module Data.Torrent.MetainfoSpec (spec) where
-
-import Control.Applicative
-import Data.ByteString as BS
-import Data.ByteString.Lazy as BL
-import Data.BEncode
-import Data.Maybe
-import Data.Time
-import Network.URI
-import Test.Hspec
-import Test.QuickCheck
-import Test.QuickCheck.Instances ()
-
-import Data.Torrent.Piece
-import Data.Torrent.Layout
-import Data.Torrent
-import Data.Torrent.LayoutSpec ()
-import Network.BitTorrent.Core.NodeInfoSpec ()
-
-{-----------------------------------------------------------------------
---  Common
------------------------------------------------------------------------}
-
-data T a = T
-
-prop_properBEncode :: Show a => BEncode a => Eq a
-                   => T a -> a -> IO ()
-prop_properBEncode _ expected = actual `shouldBe` Right expected
-  where
-    actual = decode $ BL.toStrict $ encode expected
-
-instance Arbitrary URI where
-  arbitrary = pure $ fromJust
-              $ parseURI "http://exsample.com:80/123365_asd"
-
-{-----------------------------------------------------------------------
---  Instances
------------------------------------------------------------------------}
-
-instance Arbitrary HashList where
-  arbitrary = HashList <$> arbitrary
-
-instance Arbitrary PieceInfo where
-  arbitrary = PieceInfo <$> arbitrary <*> arbitrary
-
-instance Arbitrary InfoDict where
-  arbitrary = infoDictionary <$> arbitrary <*> arbitrary <*> arbitrary
-
-pico :: Gen (Maybe NominalDiffTime)
-pico = oneof
-  [ pure Nothing
-  , (Just . fromIntegral) <$> (arbitrary :: Gen Int)
-  ]
-
-instance Arbitrary Torrent where
-  arbitrary = Torrent <$> arbitrary
-                 <*> arbitrary <*> arbitrary    <*> arbitrary
-                 <*> pico      <*> arbitrary    <*> arbitrary
-                 <*> arbitrary
-                 <*> arbitrary <*> pure Nothing <*> arbitrary
-
-{-----------------------------------------------------------------------
---  Spec
------------------------------------------------------------------------}
-
-spec :: Spec
-spec = do
-  describe "FileInfo" $ do
-    it "properly bencoded" $ property $
-      prop_properBEncode (T :: T (FileInfo BS.ByteString))
-
-  describe "LayoutInfo" $ do
-    it "properly bencoded" $ property $
-      prop_properBEncode (T :: T LayoutInfo)
-
-  describe "Torrent" $ do
-    it "property bencoded" $ property $
-      prop_properBEncode (T :: T Torrent)
diff --git a/tests/Data/Torrent/PieceSpec.hs b/tests/Data/Torrent/PieceSpec.hs
deleted file mode 100644
index ef1f2938..00000000
--- a/tests/Data/Torrent/PieceSpec.hs
+++ /dev/null
@@ -1,13 +0,0 @@
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-module Data.Torrent.PieceSpec (spec) where
-import Control.Applicative
-import Test.Hspec
-import Test.QuickCheck
-import Data.Torrent.Piece
-
-
-instance Arbitrary a => Arbitrary (Piece a) where
-  arbitrary = Piece <$> arbitrary <*> arbitrary
-
-spec :: Spec
-spec = return ()
\ No newline at end of file
diff --git a/tests/Data/TorrentSpec.hs b/tests/Data/TorrentSpec.hs
new file mode 100644
index 00000000..b4a280e4
--- /dev/null
+++ b/tests/Data/TorrentSpec.hs
@@ -0,0 +1,139 @@
+{-# LANGUAGE TypeSynonymInstances       #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE StandaloneDeriving         #-}
+{-# OPTIONS -fno-warn-orphans           #-}
+module Data.TorrentSpec (spec) where
+import Control.Applicative
+import Data.BEncode
+import Data.ByteString as BS
+import Data.ByteString.Lazy as BL
+import Data.Convertible
+import Data.Maybe
+import Data.Monoid
+import Data.Time
+import Network.URI
+import System.FilePath
+import System.Posix.Types
+import Test.Hspec
+import Test.QuickCheck
+import Test.QuickCheck.Instances ()
+
+import Data.Torrent
+import Network.BitTorrent.CoreSpec ()
+
+
+pico :: Gen (Maybe NominalDiffTime)
+pico = oneof
+  [ pure Nothing
+  , (Just . fromIntegral) <$> (arbitrary :: Gen Int)
+  ]
+
+instance Arbitrary COff where
+  arbitrary = fromIntegral <$> (arbitrary :: Gen Int)
+
+instance Arbitrary URIAuth where
+  arbitrary = URIAuth <$> arbitrary <*> arbitrary <*> arbitrary
+
+instance Arbitrary URI where
+  arbitrary
+    = pure $ fromJust $ parseURI "http://ietf.org/1737.txt?a=1&b=h#123"
+
+instance Arbitrary InfoHash where
+  arbitrary = do
+    bs <- BS.pack <$> vectorOf 20 arbitrary
+    pure $ either (const (error "arbitrary infohash")) id $ safeConvert bs
+
+instance Arbitrary a => Arbitrary (FileInfo a) where
+  arbitrary = FileInfo <$> arbitrary <*> arbitrary <*> arbitrary
+
+instance Arbitrary LayoutInfo where
+  arbitrary = oneof
+    [ SingleFile <$> arbitrary
+    , MultiFile  <$> arbitrary <*> arbitrary
+    ]
+
+instance Arbitrary a => Arbitrary (Piece a) where
+  arbitrary = Piece <$> arbitrary <*> arbitrary
+
+instance Arbitrary HashList where
+  arbitrary = HashList <$> arbitrary
+
+instance Arbitrary PieceInfo where
+  arbitrary = PieceInfo <$> arbitrary <*> arbitrary
+
+instance Arbitrary InfoDict where
+  arbitrary = infoDictionary <$> arbitrary <*> arbitrary <*> arbitrary
+
+instance Arbitrary Torrent where
+  arbitrary = Torrent <$> arbitrary
+                 <*> arbitrary <*> arbitrary    <*> arbitrary
+                 <*> pico      <*> arbitrary    <*> arbitrary
+                 <*> arbitrary
+                 <*> arbitrary <*> pure Nothing <*> arbitrary
+
+instance Arbitrary Magnet where
+  arbitrary = Magnet <$> arbitrary <*> arbitrary
+    <*> arbitrary <*> arbitrary <*> arbitrary <*> arbitrary
+    <*> arbitrary <*> arbitrary <*> pure mempty
+
+type TestPair = (FilePath, String)
+
+-- TODO add a few more torrents here
+torrentList :: [TestPair]
+torrentList =
+  [ ( "res" </> "dapper-dvd-amd64.iso.torrent"
+    , "0221caf96aa3cb94f0f58d458e78b0fc344ad8bf")
+  ]
+
+infohashSpec :: (FilePath, String) -> Spec
+infohashSpec (filepath, expectedHash) = do
+  it ("should match " ++ filepath) $ do
+    torrent    <- fromFile filepath
+    let actualHash = show $ idInfoHash $ tInfoDict torrent
+    actualHash `shouldBe` expectedHash
+
+magnetEncoding :: Magnet -> IO ()
+magnetEncoding m = parseMagnet (renderMagnet m) `shouldBe` Just m
+
+data T a = T
+
+prop_properBEncode :: Show a => BEncode a => Eq a
+                   => T a -> a -> IO ()
+prop_properBEncode _ expected = actual `shouldBe` Right expected
+  where
+    actual = decode $ BL.toStrict $ encode expected
+
+spec :: Spec
+spec = do
+  describe "info hash" $ do
+    mapM_ infohashSpec torrentList
+
+  describe "accumPosition" $ do
+    it "" $ property $ \ p1 p2 p3 s1 s2 s3 ->
+      accumPositions [(p1, s1), (p2, s2), (p3, s3)]
+        `shouldBe`   [(p1, (0, s1)), (p2, (s1, s2)), (p3, (s1 + s2, s3))]
+
+  describe "FileInfo" $ do
+    it "properly bencoded" $ property $
+      prop_properBEncode (T :: T (FileInfo BS.ByteString))
+
+  describe "LayoutInfo" $ do
+    it "properly bencoded" $ property $
+      prop_properBEncode (T :: T LayoutInfo)
+
+  describe "Torrent" $ do
+    it "property bencoded" $ property $
+      prop_properBEncode (T :: T Torrent)
+
+  describe "Magnet" $ do
+    it "properly encoded" $ property $ magnetEncoding
+
+    it "parse base32" $ do
+      let magnet = "magnet:?xt=urn:btih:CT76LXJDDCH5LS2TUHKH6EUJ3NYKX4Y6"
+      let ih = "CT76LXJDDCH5LS2TUHKH6EUJ3NYKX4Y6"
+      parseMagnet magnet `shouldBe` Just (nullMagnet ih)
+
+    it "parse base16" $ do
+      let magnet = "magnet:?xt=urn:btih:0123456789abcdef0123456789abcdef01234567"
+      let ih = "0123456789abcdef0123456789abcdef01234567"
+      parseMagnet magnet `shouldBe` Just (nullMagnet ih)
diff --git a/tests/Network/BitTorrent/Client/HandleSpec.hs b/tests/Network/BitTorrent/Client/HandleSpec.hs
index 8e16d9b0..d51bab02 100644
--- a/tests/Network/BitTorrent/Client/HandleSpec.hs
+++ b/tests/Network/BitTorrent/Client/HandleSpec.hs
@@ -2,7 +2,7 @@ module Network.BitTorrent.Client.HandleSpec (spec) where
 import Data.Default
 import Test.Hspec
 
-import Data.Torrent.Magnet
+import Data.Torrent
 import Network.BitTorrent.Client
 import Network.BitTorrent.Client.Handle
 
diff --git a/tests/Network/BitTorrent/Core/FingerprintSpec.hs b/tests/Network/BitTorrent/Core/FingerprintSpec.hs
deleted file mode 100644
index df62442a..00000000
--- a/tests/Network/BitTorrent/Core/FingerprintSpec.hs
+++ /dev/null
@@ -1,33 +0,0 @@
--- | see <http://bittorrent.org/beps/bep_0020.html>
-module Network.BitTorrent.Core.FingerprintSpec (spec) where
-import Test.Hspec
-import Network.BitTorrent.Core.PeerId
-
-spec :: Spec
-spec = do
-  describe "client info" $ do
-    it "decode mainline encoded peer id" $ do
-      fingerprint "M4-3-6--xxxxxxxxxxxx" `shouldBe` "Mainline-4.3.6"
-      fingerprint "M4-20-8-xxxxxxxxxxxx" `shouldBe` "Mainline-4.20.8"
-
-    it "decode azureus encoded peer id" $ do
-      fingerprint "-AZ2060-xxxxxxxxxxxx" `shouldBe` "Azureus-2060"
-      fingerprint "-BS0000-xxxxxxxxxxxx" `shouldBe` "BTSlave-0"
-
-    it "decode Shad0w style peer id" $ do
-      fingerprint "S58B-----xxxxxxxxxxx" `shouldBe` "Shadow-5.8.11"
-      fingerprint "T58B-----xxxxxxxxxxx" `shouldBe` "BitTornado-5.8.11"
-
-    it "decode bitcomet style peer id" $ do
-      fingerprint "exbc01xxxxxxxxxxxxxx" `shouldBe` "BitComet-48.49"
-      fingerprint "FUTB01xxxxxxxxxxxxxx" `shouldBe` "BitComet-48.49"
-      fingerprint "exbc01LORDxxxxxxxxxx" `shouldBe` "BitLord-48.49"
-
-    it "decode opera style peer id" $ do
-      fingerprint "OP0123xxxxxxxxxxxxxx" `shouldBe` "Opera-123"
-
-    it "decode ML donkey style peer id" $ do
-      fingerprint "-ML2.7.2-xxxxxxxxxxx" `shouldBe` "MLdonkey-0"
-
--- TODO XBT, Bits on Wheels, Queen Bee, BitTyrant, TorrenTopia,
--- BitSpirit, Rufus, G3 Torrent, FlashGet
\ No newline at end of file
diff --git a/tests/Network/BitTorrent/Core/NodeInfoSpec.hs b/tests/Network/BitTorrent/Core/NodeInfoSpec.hs
deleted file mode 100644
index fb777440..00000000
--- a/tests/Network/BitTorrent/Core/NodeInfoSpec.hs
+++ /dev/null
@@ -1,52 +0,0 @@
-{-# OPTIONS -fno-warn-orphans #-}
-module Network.BitTorrent.Core.NodeInfoSpec (spec) where
-import Control.Applicative
-import Data.Serialize as S
-import Data.String
-import Test.Hspec
-import Test.QuickCheck
-
-import Network.BitTorrent.Core
-import Network.BitTorrent.Core.PeerAddrSpec ()
-
-instance Arbitrary NodeId where
-  arbitrary = fromString <$> vector 20
-
-instance Arbitrary a => Arbitrary (NodeAddr a) where
-  arbitrary = NodeAddr <$> arbitrary <*> arbitrary
-
-instance Arbitrary a => Arbitrary (NodeInfo a) where
-  arbitrary = NodeInfo <$> arbitrary <*> arbitrary
-
-spec :: Spec
-spec = do
-  describe "NodeId" $ do
-    it "properly serialized" $ do
-      S.decode "mnopqrstuvwxyz123456"
-        `shouldBe` Right ("mnopqrstuvwxyz123456" :: NodeId)
-
-      S.encode ("mnopqrstuvwxyz123456" :: NodeId)
-        `shouldBe` "mnopqrstuvwxyz123456"
-
-    it "properly serialized (iso)" $ property $ \ nid ->
-      S.decode (S.encode nid) `shouldBe`
-        Right (nid :: NodeId)
-
-  describe "NodeAddr" $ do
-    it "properly serialized" $ do
-      S.decode "\127\0\0\1\1\2" `shouldBe`
-        Right ("127.0.0.1:258" :: NodeAddr IPv4)
-
-    it "properly serialized (iso)" $ property $ \ nid ->
-      S.decode (S.encode nid) `shouldBe`
-        Right (nid :: NodeAddr IPv4)
-
-  describe "NodeInfo" $ do
-    it "properly serialized" $ do
-      S.decode "mnopqrstuvwxyz123456\
-               \\127\0\0\1\1\2" `shouldBe` Right
-       (NodeInfo "mnopqrstuvwxyz123456" "127.0.0.1:258" :: NodeInfo IPv4)
-
-    it "properly serialized (iso)" $ property $ \ nid ->
-      S.decode (S.encode nid) `shouldBe`
-        Right (nid :: NodeInfo IPv4)
diff --git a/tests/Network/BitTorrent/Core/PeerAddrSpec.hs b/tests/Network/BitTorrent/Core/PeerAddrSpec.hs
deleted file mode 100644
index abb90183..00000000
--- a/tests/Network/BitTorrent/Core/PeerAddrSpec.hs
+++ /dev/null
@@ -1,221 +0,0 @@
-{-# LANGUAGE FlexibleInstances    #-}
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-module Network.BitTorrent.Core.PeerAddrSpec (spec) where
-import Control.Applicative
-import Data.BEncode as BE
-import Data.ByteString.Lazy as BL
-import Data.IP
-import Data.Serialize as S
-import Data.Word
-import Network
-import Test.Hspec
-import Test.QuickCheck
-
-import Network.BitTorrent.Core.PeerIdSpec hiding (spec)
-import Network.BitTorrent.Core.PeerAddr
-
-instance Arbitrary IPv4 where
-  arbitrary = do
-    a <- choose (0, 255)
-    b <- choose (0, 255)
-    c <- choose (0, 255)
-    d <- choose (0, 255)
-    return $ toIPv4 [a, b, c, d]
-
-instance Arbitrary IPv6 where
-  arbitrary = do
-    a <- choose (0, fromIntegral (maxBound :: Word16))
-    b <- choose (0, fromIntegral (maxBound :: Word16))
-    c <- choose (0, fromIntegral (maxBound :: Word16))
-    d <- choose (0, fromIntegral (maxBound :: Word16))
-    e <- choose (0, fromIntegral (maxBound :: Word16))
-    f <- choose (0, fromIntegral (maxBound :: Word16))
-    g <- choose (0, fromIntegral (maxBound :: Word16))
-    h <- choose (0, fromIntegral (maxBound :: Word16))
-    return $ toIPv6 [a, b, c, d, e, f, g, h]
-
-instance Arbitrary IP where
-  arbitrary = frequency
-    [ (1, IPv4 <$> arbitrary)
-    , (1, IPv6 <$> arbitrary)
-    ]
-
-instance Arbitrary PortNumber where
-  arbitrary = fromIntegral <$> (arbitrary :: Gen Word16)
-
-instance Arbitrary a => Arbitrary (PeerAddr a) where
-  arbitrary = PeerAddr <$> arbitrary <*> arbitrary <*> arbitrary
-
-spec :: Spec
-spec = do
-  describe "PortNumber" $ do
-    it "properly serialized" $ do
-      S.decode "\x1\x2" `shouldBe` Right (258 :: PortNumber)
-      S.encode (258 :: PortNumber) `shouldBe` "\x1\x2"
-
-    it "properly bencoded" $ do
-      BE.decode "i80e" `shouldBe` Right (80 :: PortNumber)
-
-    it "fail if port number is invalid" $ do
-      (BE.decode "i-10e" :: BE.Result PortNumber)
-        `shouldBe`
-        Left "fromBEncode: unable to decode PortNumber: -10"
-
-      (BE.decode "i70000e" :: BE.Result PortNumber)
-        `shouldBe`
-        Left "fromBEncode: unable to decode PortNumber: 70000"
-
-  describe "Peer IPv4" $ do
-    it "properly serialized" $ do
-      S.decode "\x1\x2\x3\x4" `shouldBe` Right (toIPv4 [1, 2, 3, 4])
-      S.encode (toIPv4 [1, 2, 3, 4]) `shouldBe` "\x1\x2\x3\x4"
-
-    it "properly serialized (iso)" $ property $ \ ip -> do
-      S.decode (S.encode ip) `shouldBe` Right (ip :: IPv4)
-
-    it "properly bencoded" $ do
-      BE.decode "11:168.192.0.1" `shouldBe` Right (toIPv4 [168, 192, 0, 1])
-      BE.encode (toIPv4 [168, 192, 0, 1]) `shouldBe` "11:168.192.0.1"
-
-    it "properly bencoded (iso)" $ property $ \ ip ->
-      BE.decode (BL.toStrict (BE.encode ip)) `shouldBe` Right (ip :: IPv4)
-
-    it "fail gracefully on invalid strings" $ do
-      BE.decode "3:1.1" `shouldBe`
-        (Left "fromBEncode: unable to decode IP: 1.1" :: BE.Result IPv4)
-
-    it "fail gracefully on invalid bencode" $ do
-      BE.decode "i10e" `shouldBe`
-        (Left "fromBEncode: unable to decode IP: addr should be a bstring"
-         :: BE.Result IPv4)
-
-  describe "Peer IPv6" $ do
-    it "properly serialized" $ do
-      S.decode "\x1\x2\x3\x4\x5\x6\x7\x8\x9\xa\xb\xc\xd\xe\xf\x10"
-        `shouldBe`
-        Right ("102:304:506:708:90a:b0c:d0e:f10" :: IPv6)
-
-      S.encode ("102:304:506:708:90a:b0c:d0e:f10" :: IPv6)
-        `shouldBe`
-        "\x1\x2\x3\x4\x5\x6\x7\x8\x9\xa\xb\xc\xd\xe\xf\x10"
-
-    it "properly serialized (iso)" $ property $ \ ip ->
-      S.decode (S.encode ip) `shouldBe` Right (ip :: IPv6)
-
-    it "properly bencoded" $ do
-      BE.decode "3:::1" `shouldBe` Right (toIPv6 [0, 0, 0, 0, 0, 0, 0, 1])
-      BE.encode (toIPv6 [0, 0, 0, 0, 0, 0, 0, 1]) `shouldBe`
-        "23:00:00:00:00:00:00:00:01"
-
-      BE.decode "23:00:00:00:00:00:00:00:01"
-        `shouldBe`
-        Right (toIPv6 [0, 0, 0, 0, 0, 0, 0, 1])
-
-    it "properly bencoded iso" $ property $ \ ip ->
-      BE.decode (BL.toStrict (BE.encode ip)) `shouldBe` Right (ip :: IPv4)
-
-    it "fail gracefully on invalid strings" $ do
-      BE.decode "4:g::1" `shouldBe`
-        (Left "fromBEncode: unable to decode IP: g::1" :: BE.Result IPv6)
-
-    it "fail gracefully on invalid bencode" $ do
-      BE.decode "i10e" `shouldBe`
-        (Left "fromBEncode: unable to decode IP: addr should be a bstring"
-         :: BE.Result IPv6)
-
-
-  describe "Peer IP" $ do
-    it "properly serialized IPv6" $ do
-      S.decode "\x1\x2\x3\x4\x5\x6\x7\x8\x9\xa\xb\xc\xd\xe\xf\x10"
-        `shouldBe`
-        Right ("102:304:506:708:90a:b0c:d0e:f10" :: IP)
-
-      S.encode ("102:304:506:708:90a:b0c:d0e:f10" :: IP)
-        `shouldBe`
-        "\x1\x2\x3\x4\x5\x6\x7\x8\x9\xa\xb\xc\xd\xe\xf\x10"
-
-    it "properly serialized (iso) IPv6" $ property $ \ ip ->
-      S.decode (S.encode ip) `shouldBe` Right (ip :: IP)
-
-    it "properly serialized IPv4" $ do
-      S.decode "\x1\x2\x3\x4" `shouldBe` Right (IPv4 $ toIPv4 [1, 2, 3, 4])
-      S.encode (toIPv4 [1, 2, 3, 4]) `shouldBe` "\x1\x2\x3\x4"
-
-    it "properly serialized (iso) IPv4" $ property $ \ ip -> do
-      S.decode (S.encode ip) `shouldBe` Right (ip :: IP)
-
-    it "properly bencoded" $ do
-      BE.decode "11:168.192.0.1" `shouldBe`
-        Right (IPv4 (toIPv4 [168, 192, 0, 1]))
-
-      BE.decode "3:::1" `shouldBe` Right
-         (IPv6 (toIPv6 [0, 0, 0, 0, 0, 0, 0, 1]))
-
-      BE.encode (IPv6 (toIPv6 [0, 0, 0, 0, 0, 0, 0, 1])) `shouldBe`
-        "23:00:00:00:00:00:00:00:01"
-
-      BE.decode "23:00:00:00:00:00:00:00:01"
-        `shouldBe`
-        Right (IPv6 (toIPv6 [0, 0, 0, 0, 0, 0, 0, 1]))
-
-    it "properly bencoded iso" $ property $ \ ip ->
-      BE.decode (BL.toStrict (BE.encode ip)) `shouldBe` Right (ip :: IP)
-
-    it "fail gracefully on invalid strings" $ do
-      BE.decode "4:g::1" `shouldBe`
-        (Left "fromBEncode: unable to decode IP: g::1" :: BE.Result IP)
-
-    it "fail gracefully on invalid bencode" $ do
-      BE.decode "i10e" `shouldBe`
-        (Left "fromBEncode: unable to decode IP: addr should be a bstring"
-         :: BE.Result IP)
-
-  describe "PeerAddr" $ do
-    it "IsString" $ do
-      ("127.0.0.1:80" :: PeerAddr IP)
-        `shouldBe` PeerAddr Nothing "127.0.0.1" 80
-
-      ("127.0.0.1:80" :: PeerAddr IPv4)
-        `shouldBe` PeerAddr Nothing "127.0.0.1" 80
-
-      ("[::1]:80"     :: PeerAddr IP)
-        `shouldBe` PeerAddr Nothing "::1"       80
-
-      ("[::1]:80"     :: PeerAddr IPv6)
-        `shouldBe` PeerAddr Nothing "::1"       80
-
-    it "properly bencoded (iso)" $ property $ \ addr ->
-      BE.decode (BL.toStrict (BE.encode addr))
-        `shouldBe` Right (addr :: PeerAddr IP)
-
-
-    it "properly bencoded (ipv4)" $ do
-      BE.decode "d2:ip11:168.192.0.1\
-                 \7:peer id20:01234567890123456789\
-                 \4:porti6881e\
-                 \e"
-        `shouldBe`
-        Right (PeerAddr (Just "01234567890123456789")
-                        (IPv4 (toIPv4 [168, 192, 0, 1]))
-                        6881)
-
-    it "properly bencoded (ipv6)" $ do
-      BE.decode "d2:ip3:::1\
-                 \7:peer id20:01234567890123456789\
-                 \4:porti6881e\
-                 \e"
-        `shouldBe`
-        Right (PeerAddr (Just "01234567890123456789")
-                        (IPv6 (toIPv6 [0, 0, 0, 0, 0, 0, 0, 1]))
-                        6881)
-
-    it "peer id is optional" $ do
-      BE.decode "d2:ip11:168.192.0.1\
-                 \4:porti6881e\
-                 \e"
-        `shouldBe`
-        Right (PeerAddr Nothing (IPv4 (toIPv4 [168, 192, 0, 1])) 6881)
-
-    it "has sock addr for both ipv4 and ipv6" $ do
-      show (peerSockAddr "128.0.0.1:80") `shouldBe` "128.0.0.1:80"
-      show (peerSockAddr "[::1]:8080"  ) `shouldBe` "[::1]:8080"
diff --git a/tests/Network/BitTorrent/Core/PeerIdSpec.hs b/tests/Network/BitTorrent/Core/PeerIdSpec.hs
deleted file mode 100644
index 4b0c2398..00000000
--- a/tests/Network/BitTorrent/Core/PeerIdSpec.hs
+++ /dev/null
@@ -1,25 +0,0 @@
-{-# OPTIONS -fno-warn-orphans #-}
-module Network.BitTorrent.Core.PeerIdSpec (spec) where
-import Control.Applicative
-import Data.BEncode as BE
-import Data.Text.Encoding as T
-import Test.Hspec
-import Test.QuickCheck
-import Test.QuickCheck.Instances ()
-import Network.BitTorrent.Core.PeerId
-
-
-instance Arbitrary PeerId where
-  arbitrary = oneof
-    [ azureusStyle defaultClientId defaultVersionNumber
-        <$> (T.encodeUtf8 <$> arbitrary)
-    , shadowStyle  'X'             defaultVersionNumber
-        <$> (T.encodeUtf8 <$> arbitrary)
-    ]
-
-spec :: Spec
-spec = do
-  describe "PeerId" $ do
-    it "properly bencoded" $ do
-      BE.decode "20:01234567890123456789"
-        `shouldBe` Right ("01234567890123456789" :: PeerId)
\ No newline at end of file
diff --git a/tests/Network/BitTorrent/CoreSpec.hs b/tests/Network/BitTorrent/CoreSpec.hs
index 460c52be..5bf900b2 100644
--- a/tests/Network/BitTorrent/CoreSpec.hs
+++ b/tests/Network/BitTorrent/CoreSpec.hs
@@ -1,11 +1,305 @@
--- | Re-export modules.
+{-# LANGUAGE FlexibleInstances    #-}
+{-# OPTIONS_GHC -fno-warn-orphans #-}
 module Network.BitTorrent.CoreSpec (spec) where
-import Network.BitTorrent.Core.FingerprintSpec as CoreSpec ()
-import Network.BitTorrent.Core.NodeInfoSpec    as CoreSpec ()
-import Network.BitTorrent.Core.PeerIdSpec      as CoreSpec ()
-import Network.BitTorrent.Core.PeerAddrSpec    as CoreSpec ()
+import Control.Applicative
+import Data.BEncode as BE
+import Data.ByteString.Lazy as BL
+import Data.IP
+import Data.Serialize as S
+import Data.String
+import Data.Text.Encoding as T
+import Data.Word
+import Network
+import Test.Hspec
+import Test.QuickCheck
+import Test.QuickCheck.Instances ()
 
-import Test.Hspec (Spec)
+import Network.BitTorrent.Address
+
+
+instance Arbitrary IPv4 where
+  arbitrary = do
+    a <- choose (0, 255)
+    b <- choose (0, 255)
+    c <- choose (0, 255)
+    d <- choose (0, 255)
+    return $ toIPv4 [a, b, c, d]
+
+instance Arbitrary IPv6 where
+  arbitrary = do
+    a <- choose (0, fromIntegral (maxBound :: Word16))
+    b <- choose (0, fromIntegral (maxBound :: Word16))
+    c <- choose (0, fromIntegral (maxBound :: Word16))
+    d <- choose (0, fromIntegral (maxBound :: Word16))
+    e <- choose (0, fromIntegral (maxBound :: Word16))
+    f <- choose (0, fromIntegral (maxBound :: Word16))
+    g <- choose (0, fromIntegral (maxBound :: Word16))
+    h <- choose (0, fromIntegral (maxBound :: Word16))
+    return $ toIPv6 [a, b, c, d, e, f, g, h]
+
+instance Arbitrary IP where
+  arbitrary = frequency
+    [ (1, IPv4 <$> arbitrary)
+    , (1, IPv6 <$> arbitrary)
+    ]
+
+instance Arbitrary PortNumber where
+  arbitrary = fromIntegral <$> (arbitrary :: Gen Word16)
+
+instance Arbitrary PeerId where
+  arbitrary = oneof
+    [ azureusStyle defaultClientId defaultVersionNumber
+        <$> (T.encodeUtf8 <$> arbitrary)
+    , shadowStyle  'X'             defaultVersionNumber
+        <$> (T.encodeUtf8 <$> arbitrary)
+    ]
+
+instance Arbitrary a => Arbitrary (PeerAddr a) where
+  arbitrary = PeerAddr <$> arbitrary <*> arbitrary <*> arbitrary
+
+instance Arbitrary NodeId where
+  arbitrary = fromString <$> vector 20
+
+instance Arbitrary a => Arbitrary (NodeAddr a) where
+  arbitrary = NodeAddr <$> arbitrary <*> arbitrary
+
+instance Arbitrary a => Arbitrary (NodeInfo a) where
+  arbitrary = NodeInfo <$> arbitrary <*> arbitrary
 
 spec :: Spec
-spec = return ()
\ No newline at end of file
+spec = do
+  describe "PeerId" $ do
+    it "properly bencoded" $ do
+      BE.decode "20:01234567890123456789"
+        `shouldBe` Right ("01234567890123456789" :: PeerId)
+
+  describe "PortNumber" $ do
+    it "properly serialized" $ do
+      S.decode "\x1\x2" `shouldBe` Right (258 :: PortNumber)
+      S.encode (258 :: PortNumber) `shouldBe` "\x1\x2"
+
+    it "properly bencoded" $ do
+      BE.decode "i80e" `shouldBe` Right (80 :: PortNumber)
+
+    it "fail if port number is invalid" $ do
+      (BE.decode "i-10e" :: BE.Result PortNumber)
+        `shouldBe`
+        Left "fromBEncode: unable to decode PortNumber: -10"
+
+      (BE.decode "i70000e" :: BE.Result PortNumber)
+        `shouldBe`
+        Left "fromBEncode: unable to decode PortNumber: 70000"
+
+  describe "Peer IPv4" $ do
+    it "properly serialized" $ do
+      S.decode "\x1\x2\x3\x4" `shouldBe` Right (toIPv4 [1, 2, 3, 4])
+      S.encode (toIPv4 [1, 2, 3, 4]) `shouldBe` "\x1\x2\x3\x4"
+
+    it "properly serialized (iso)" $ property $ \ ip -> do
+      S.decode (S.encode ip) `shouldBe` Right (ip :: IPv4)
+
+    it "properly bencoded" $ do
+      BE.decode "11:168.192.0.1" `shouldBe` Right (toIPv4 [168, 192, 0, 1])
+      BE.encode (toIPv4 [168, 192, 0, 1]) `shouldBe` "11:168.192.0.1"
+
+    it "properly bencoded (iso)" $ property $ \ ip ->
+      BE.decode (BL.toStrict (BE.encode ip)) `shouldBe` Right (ip :: IPv4)
+
+    it "fail gracefully on invalid strings" $ do
+      BE.decode "3:1.1" `shouldBe`
+        (Left "fromBEncode: unable to decode IP: 1.1" :: BE.Result IPv4)
+
+    it "fail gracefully on invalid bencode" $ do
+      BE.decode "i10e" `shouldBe`
+        (Left "fromBEncode: unable to decode IP: addr should be a bstring"
+         :: BE.Result IPv4)
+
+  describe "Peer IPv6" $ do
+    it "properly serialized" $ do
+      S.decode "\x1\x2\x3\x4\x5\x6\x7\x8\x9\xa\xb\xc\xd\xe\xf\x10"
+        `shouldBe`
+        Right ("102:304:506:708:90a:b0c:d0e:f10" :: IPv6)
+
+      S.encode ("102:304:506:708:90a:b0c:d0e:f10" :: IPv6)
+        `shouldBe`
+        "\x1\x2\x3\x4\x5\x6\x7\x8\x9\xa\xb\xc\xd\xe\xf\x10"
+
+    it "properly serialized (iso)" $ property $ \ ip ->
+      S.decode (S.encode ip) `shouldBe` Right (ip :: IPv6)
+
+    it "properly bencoded" $ do
+      BE.decode "3:::1" `shouldBe` Right (toIPv6 [0, 0, 0, 0, 0, 0, 0, 1])
+      BE.encode (toIPv6 [0, 0, 0, 0, 0, 0, 0, 1]) `shouldBe`
+        "23:00:00:00:00:00:00:00:01"
+
+      BE.decode "23:00:00:00:00:00:00:00:01"
+        `shouldBe`
+        Right (toIPv6 [0, 0, 0, 0, 0, 0, 0, 1])
+
+    it "properly bencoded iso" $ property $ \ ip ->
+      BE.decode (BL.toStrict (BE.encode ip)) `shouldBe` Right (ip :: IPv4)
+
+    it "fail gracefully on invalid strings" $ do
+      BE.decode "4:g::1" `shouldBe`
+        (Left "fromBEncode: unable to decode IP: g::1" :: BE.Result IPv6)
+
+    it "fail gracefully on invalid bencode" $ do
+      BE.decode "i10e" `shouldBe`
+        (Left "fromBEncode: unable to decode IP: addr should be a bstring"
+         :: BE.Result IPv6)
+
+
+  describe "Peer IP" $ do
+    it "properly serialized IPv6" $ do
+      S.decode "\x1\x2\x3\x4\x5\x6\x7\x8\x9\xa\xb\xc\xd\xe\xf\x10"
+        `shouldBe`
+        Right ("102:304:506:708:90a:b0c:d0e:f10" :: IP)
+
+      S.encode ("102:304:506:708:90a:b0c:d0e:f10" :: IP)
+        `shouldBe`
+        "\x1\x2\x3\x4\x5\x6\x7\x8\x9\xa\xb\xc\xd\xe\xf\x10"
+
+    it "properly serialized (iso) IPv6" $ property $ \ ip ->
+      S.decode (S.encode ip) `shouldBe` Right (ip :: IP)
+
+    it "properly serialized IPv4" $ do
+      S.decode "\x1\x2\x3\x4" `shouldBe` Right (IPv4 $ toIPv4 [1, 2, 3, 4])
+      S.encode (toIPv4 [1, 2, 3, 4]) `shouldBe` "\x1\x2\x3\x4"
+
+    it "properly serialized (iso) IPv4" $ property $ \ ip -> do
+      S.decode (S.encode ip) `shouldBe` Right (ip :: IP)
+
+    it "properly bencoded" $ do
+      BE.decode "11:168.192.0.1" `shouldBe`
+        Right (IPv4 (toIPv4 [168, 192, 0, 1]))
+
+      BE.decode "3:::1" `shouldBe` Right
+         (IPv6 (toIPv6 [0, 0, 0, 0, 0, 0, 0, 1]))
+
+      BE.encode (IPv6 (toIPv6 [0, 0, 0, 0, 0, 0, 0, 1])) `shouldBe`
+        "23:00:00:00:00:00:00:00:01"
+
+      BE.decode "23:00:00:00:00:00:00:00:01"
+        `shouldBe`
+        Right (IPv6 (toIPv6 [0, 0, 0, 0, 0, 0, 0, 1]))
+
+    it "properly bencoded iso" $ property $ \ ip ->
+      BE.decode (BL.toStrict (BE.encode ip)) `shouldBe` Right (ip :: IP)
+
+    it "fail gracefully on invalid strings" $ do
+      BE.decode "4:g::1" `shouldBe`
+        (Left "fromBEncode: unable to decode IP: g::1" :: BE.Result IP)
+
+    it "fail gracefully on invalid bencode" $ do
+      BE.decode "i10e" `shouldBe`
+        (Left "fromBEncode: unable to decode IP: addr should be a bstring"
+         :: BE.Result IP)
+
+  describe "PeerAddr" $ do
+    it "IsString" $ do
+      ("127.0.0.1:80" :: PeerAddr IP)
+        `shouldBe` PeerAddr Nothing "127.0.0.1" 80
+
+      ("127.0.0.1:80" :: PeerAddr IPv4)
+        `shouldBe` PeerAddr Nothing "127.0.0.1" 80
+
+      ("[::1]:80"     :: PeerAddr IP)
+        `shouldBe` PeerAddr Nothing "::1"       80
+
+      ("[::1]:80"     :: PeerAddr IPv6)
+        `shouldBe` PeerAddr Nothing "::1"       80
+
+    it "properly bencoded (iso)" $ property $ \ addr ->
+      BE.decode (BL.toStrict (BE.encode addr))
+        `shouldBe` Right (addr :: PeerAddr IP)
+
+
+    it "properly bencoded (ipv4)" $ do
+      BE.decode "d2:ip11:168.192.0.1\
+                 \7:peer id20:01234567890123456789\
+                 \4:porti6881e\
+                 \e"
+        `shouldBe`
+        Right (PeerAddr (Just "01234567890123456789")
+                        (IPv4 (toIPv4 [168, 192, 0, 1]))
+                        6881)
+
+    it "properly bencoded (ipv6)" $ do
+      BE.decode "d2:ip3:::1\
+                 \7:peer id20:01234567890123456789\
+                 \4:porti6881e\
+                 \e"
+        `shouldBe`
+        Right (PeerAddr (Just "01234567890123456789")
+                        (IPv6 (toIPv6 [0, 0, 0, 0, 0, 0, 0, 1]))
+                        6881)
+
+    it "peer id is optional" $ do
+      BE.decode "d2:ip11:168.192.0.1\
+                 \4:porti6881e\
+                 \e"
+        `shouldBe`
+        Right (PeerAddr Nothing (IPv4 (toIPv4 [168, 192, 0, 1])) 6881)
+
+    it "has sock addr for both ipv4 and ipv6" $ do
+      show (peerSockAddr "128.0.0.1:80") `shouldBe` "128.0.0.1:80"
+      show (peerSockAddr "[::1]:8080"  ) `shouldBe` "[::1]:8080"
+
+  describe "NodeId" $ do
+    it "properly serialized" $ do
+      S.decode "mnopqrstuvwxyz123456"
+        `shouldBe` Right ("mnopqrstuvwxyz123456" :: NodeId)
+
+      S.encode ("mnopqrstuvwxyz123456" :: NodeId)
+        `shouldBe` "mnopqrstuvwxyz123456"
+
+    it "properly serialized (iso)" $ property $ \ nid ->
+      S.decode (S.encode nid) `shouldBe`
+        Right (nid :: NodeId)
+
+  describe "NodeAddr" $ do
+    it "properly serialized" $ do
+      S.decode "\127\0\0\1\1\2" `shouldBe`
+        Right ("127.0.0.1:258" :: NodeAddr IPv4)
+
+    it "properly serialized (iso)" $ property $ \ nid ->
+      S.decode (S.encode nid) `shouldBe`
+        Right (nid :: NodeAddr IPv4)
+
+  describe "NodeInfo" $ do
+    it "properly serialized" $ do
+      S.decode "mnopqrstuvwxyz123456\
+               \\127\0\0\1\1\2" `shouldBe` Right
+       (NodeInfo "mnopqrstuvwxyz123456" "127.0.0.1:258" :: NodeInfo IPv4)
+
+    it "properly serialized (iso)" $ property $ \ nid ->
+      S.decode (S.encode nid) `shouldBe`
+        Right (nid :: NodeInfo IPv4)
+
+  --  see <http://bittorrent.org/beps/bep_0020.html>
+  describe "Fingerprint" $ do
+    it "decode mainline encoded peer id" $ do
+      fingerprint "M4-3-6--xxxxxxxxxxxx" `shouldBe` "Mainline-4.3.6"
+      fingerprint "M4-20-8-xxxxxxxxxxxx" `shouldBe` "Mainline-4.20.8"
+
+    it "decode azureus encoded peer id" $ do
+      fingerprint "-AZ2060-xxxxxxxxxxxx" `shouldBe` "Azureus-2060"
+      fingerprint "-BS0000-xxxxxxxxxxxx" `shouldBe` "BTSlave-0"
+
+    it "decode Shad0w style peer id" $ do
+      fingerprint "S58B-----xxxxxxxxxxx" `shouldBe` "Shadow-5.8.11"
+      fingerprint "T58B-----xxxxxxxxxxx" `shouldBe` "BitTornado-5.8.11"
+
+    it "decode bitcomet style peer id" $ do
+      fingerprint "exbc01xxxxxxxxxxxxxx" `shouldBe` "BitComet-48.49"
+      fingerprint "FUTB01xxxxxxxxxxxxxx" `shouldBe` "BitComet-48.49"
+      fingerprint "exbc01LORDxxxxxxxxxx" `shouldBe` "BitLord-48.49"
+
+    it "decode opera style peer id" $ do
+      fingerprint "OP0123xxxxxxxxxxxxxx" `shouldBe` "Opera-123"
+
+    it "decode ML donkey style peer id" $ do
+      fingerprint "-ML2.7.2-xxxxxxxxxxx" `shouldBe` "MLdonkey-0"
+
+-- TODO XBT, Bits on Wheels, Queen Bee, BitTyrant, TorrenTopia,
+-- BitSpirit, Rufus, G3 Torrent, FlashGet
\ No newline at end of file
diff --git a/tests/Network/BitTorrent/DHT/MessageSpec.hs b/tests/Network/BitTorrent/DHT/MessageSpec.hs
index 4ec875dd..ab6e1ea5 100644
--- a/tests/Network/BitTorrent/DHT/MessageSpec.hs
+++ b/tests/Network/BitTorrent/DHT/MessageSpec.hs
@@ -8,7 +8,7 @@ import Data.ByteString.Lazy as BL
 import Data.Default
 import Data.List as L
 import Data.Maybe
-import Network.BitTorrent.Core
+import Network.BitTorrent.Address
 import Network.BitTorrent.DHT.Message
 import qualified Network.KRPC as KRPC (def)
 import Network.KRPC hiding (def)
@@ -17,9 +17,9 @@ import Test.Hspec
 import Test.QuickCheck
 import System.Timeout
 
+import Data.TorrentSpec                 ()
 import Network.BitTorrent.CoreSpec      ()
 import Network.BitTorrent.DHT.TokenSpec ()
-import Data.Torrent.InfoHashSpec        ()
 
 
 instance MonadLogger IO where
diff --git a/tests/Network/BitTorrent/DHT/QuerySpec.hs b/tests/Network/BitTorrent/DHT/QuerySpec.hs
index d25bd120..81c3b45b 100644
--- a/tests/Network/BitTorrent/DHT/QuerySpec.hs
+++ b/tests/Network/BitTorrent/DHT/QuerySpec.hs
@@ -9,7 +9,7 @@ import Data.Default
 import Data.List as L
 import Test.Hspec
 
-import Network.BitTorrent.Core
+import Network.BitTorrent.Address
 import Network.BitTorrent.DHT
 import Network.BitTorrent.DHT.Session
 import Network.BitTorrent.DHT.Query
diff --git a/tests/Network/BitTorrent/DHT/RoutingSpec.hs b/tests/Network/BitTorrent/DHT/RoutingSpec.hs
index c4a33357..aeccff5f 100644
--- a/tests/Network/BitTorrent/DHT/RoutingSpec.hs
+++ b/tests/Network/BitTorrent/DHT/RoutingSpec.hs
@@ -8,7 +8,7 @@ import Data.Maybe
 import Test.Hspec
 import Test.QuickCheck
 
-import Network.BitTorrent.Core
+import Network.BitTorrent.Address
 import Network.BitTorrent.DHT.Routing as T
 
 import Network.BitTorrent.CoreSpec hiding (spec)
diff --git a/tests/Network/BitTorrent/DHT/SessionSpec.hs b/tests/Network/BitTorrent/DHT/SessionSpec.hs
index bb32cf0e..a5376c32 100644
--- a/tests/Network/BitTorrent/DHT/SessionSpec.hs
+++ b/tests/Network/BitTorrent/DHT/SessionSpec.hs
@@ -5,17 +5,18 @@ import Control.Concurrent
 import Control.Exception
 import Control.Monad.Reader
 import Control.Monad.Trans.Resource
+import Data.Conduit.Lazy
 import Data.Default
 import Data.List as L
 import Test.Hspec
 import Test.QuickCheck
 
-import Network.BitTorrent.Core
+import Network.BitTorrent.Address
 import Network.BitTorrent.DHT
 import Network.BitTorrent.DHT.Message
 import Network.BitTorrent.DHT.Session
 
-import Data.Torrent.InfoHashSpec ()
+import Data.TorrentSpec ()
 import Network.BitTorrent.CoreSpec ()
 import Network.BitTorrent.DHT.TokenSpec ()
 
diff --git a/tests/Network/BitTorrent/DHT/TestData.hs b/tests/Network/BitTorrent/DHT/TestData.hs
index 2e000a77..e9473cbb 100644
--- a/tests/Network/BitTorrent/DHT/TestData.hs
+++ b/tests/Network/BitTorrent/DHT/TestData.hs
@@ -3,7 +3,7 @@ module Network.BitTorrent.DHT.TestData
        , testTorrents
        ) where
 
-import Data.Torrent.InfoHash
+import Data.Torrent
 
 data TestEntry = TestEntry
   { entryName  :: String
diff --git a/tests/Network/BitTorrent/DHT/TokenSpec.hs b/tests/Network/BitTorrent/DHT/TokenSpec.hs
index 6353a24c..a45d2212 100644
--- a/tests/Network/BitTorrent/DHT/TokenSpec.hs
+++ b/tests/Network/BitTorrent/DHT/TokenSpec.hs
@@ -7,7 +7,7 @@ import Data.String
 import Test.Hspec
 import Test.QuickCheck
 
-import Network.BitTorrent.Core
+import Network.BitTorrent.Address
 import Network.BitTorrent.CoreSpec ()
 import Network.BitTorrent.DHT.Token as T
 
diff --git a/tests/Network/BitTorrent/DHTSpec.hs b/tests/Network/BitTorrent/DHTSpec.hs
index 76b48257..30abc867 100644
--- a/tests/Network/BitTorrent/DHTSpec.hs
+++ b/tests/Network/BitTorrent/DHTSpec.hs
@@ -6,7 +6,7 @@ import Data.List as L
 import Test.Hspec
 import System.Timeout
 
-import Data.Torrent.InfoHash
+import Data.Torrent
 import Network.BitTorrent.DHT
 
 
diff --git a/tests/Data/Torrent/BitfieldSpec.hs b/tests/Network/BitTorrent/Exchange/BitfieldSpec.hs
index 093f6f19..234965fa 100644
--- a/tests/Data/Torrent/BitfieldSpec.hs
+++ b/tests/Network/BitTorrent/Exchange/BitfieldSpec.hs
@@ -1,10 +1,10 @@
 {-# OPTIONS -fno-warn-orphans #-}
-module Data.Torrent.BitfieldSpec (spec) where
+module Network.BitTorrent.Exchange.BitfieldSpec (spec) where
 import Control.Applicative
 import Test.Hspec
 import Test.QuickCheck
 
-import Data.Torrent.Bitfield
+import Network.BitTorrent.Exchange.Bitfield
 
 instance Arbitrary Bitfield where
   arbitrary = fromBitmap <$> arbitrary
diff --git a/tests/Network/BitTorrent/Exchange/ConnectionSpec.hs b/tests/Network/BitTorrent/Exchange/ConnectionSpec.hs
index c21f55ef..d654cda1 100644
--- a/tests/Network/BitTorrent/Exchange/ConnectionSpec.hs
+++ b/tests/Network/BitTorrent/Exchange/ConnectionSpec.hs
@@ -8,8 +8,7 @@ import Test.Hspec
 import Test.QuickCheck
 
 import Data.Torrent
-import Data.Torrent.InfoHash
-import Network.BitTorrent.Core
+import Network.BitTorrent.Address
 import Network.BitTorrent.Exchange.Connection
 import Network.BitTorrent.Exchange.Message
 
diff --git a/tests/Network/BitTorrent/Exchange/Session/MetadataSpec.hs b/tests/Network/BitTorrent/Exchange/DownloadSpec.hs
index 975ceb5b..d46f2034 100644
--- a/tests/Network/BitTorrent/Exchange/Session/MetadataSpec.hs
+++ b/tests/Network/BitTorrent/Exchange/DownloadSpec.hs
@@ -1,5 +1,5 @@
 {-# LANGUAGE RecordWildCards #-}
-module Network.BitTorrent.Exchange.Session.MetadataSpec (spec) where
+module Network.BitTorrent.Exchange.DownloadSpec (spec) where
 import Control.Concurrent
 import Data.ByteString as BS
 import Data.ByteString.Lazy as BL
@@ -7,11 +7,10 @@ import Test.Hspec
 import Test.QuickCheck
 
 import Data.BEncode as BE
-import Data.Torrent
-import Data.Torrent.Piece as P
-import Network.BitTorrent.Core
+import Data.Torrent as Torrent
+import Network.BitTorrent.Address
+import Network.BitTorrent.Exchange.Download
 import Network.BitTorrent.Exchange.Message
-import Network.BitTorrent.Exchange.Session.Metadata
 
 import Config
 import Network.BitTorrent.CoreSpec ()
@@ -25,27 +24,16 @@ chunkBy s bs
   | BS.null bs = []
   | otherwise  = BS.take s bs : chunkBy s (BS.drop s bs)
 
-withUpdates :: Updates a -> IO a
+withUpdates :: Updates s a -> IO a
 withUpdates m = do
   Torrent {..} <- getTestTorrent
   let infoDictLen = fromIntegral $ BL.length $ BE.encode tInfoDict
-  mvar <- newMVar (nullStatus infoDictLen)
-  runUpdates mvar placeholderAddr m
+  --mvar <- newMVar (nullStatus infoDictLen)
+  --runUpdates mvar placeholderAddr m
+  undefined
 
-simulateFetch :: InfoDict -> Updates (Maybe InfoDict)
-simulateFetch dict = go
-  where
-    blocks = chunkBy metadataPieceSize (BL.toStrict (BE.encode dict))
-    packPiece ix = P.Piece ix (blocks !! ix)
-    ih     = idInfoHash dict
-
-    go = do
-      mix <- scheduleBlock
-      case mix of
-        Nothing -> return Nothing
-        Just ix -> do
-          mdict <- pushBlock (packPiece ix) ih
-          maybe go (return . Just) mdict
+simulateFetch :: InfoDict -> Updates s (Maybe InfoDict)
+simulateFetch dict = undefined
 
 spec :: Spec
 spec = do
diff --git a/tests/Network/BitTorrent/Exchange/MessageSpec.hs b/tests/Network/BitTorrent/Exchange/MessageSpec.hs
index 63d814ff..d615b1ff 100644
--- a/tests/Network/BitTorrent/Exchange/MessageSpec.hs
+++ b/tests/Network/BitTorrent/Exchange/MessageSpec.hs
@@ -10,10 +10,10 @@ import Data.String
 import Test.Hspec
 import Test.QuickCheck
 
-import Data.Torrent.BitfieldSpec ()
-import Data.Torrent.InfoHashSpec ()
+import Data.TorrentSpec ()
+import Network.BitTorrent.Exchange.BitfieldSpec ()
 import Network.BitTorrent.CoreSpec ()
-import Network.BitTorrent.Core ()
+import Network.BitTorrent.Address ()
 import Network.BitTorrent.Exchange.BlockSpec ()
 import Network.BitTorrent.Exchange.Message
 
diff --git a/tests/Network/BitTorrent/Exchange/SessionSpec.hs b/tests/Network/BitTorrent/Exchange/SessionSpec.hs
index c2c76644..bf5b95a1 100644
--- a/tests/Network/BitTorrent/Exchange/SessionSpec.hs
+++ b/tests/Network/BitTorrent/Exchange/SessionSpec.hs
@@ -3,7 +3,7 @@ module Network.BitTorrent.Exchange.SessionSpec (spec) where
 import Test.Hspec
 
 import Data.Torrent
-import Network.BitTorrent.Core
+import Network.BitTorrent.Address
 import Network.BitTorrent.Exchange.Session
 
 import Config
diff --git a/tests/Data/Torrent/ProgressSpec.hs b/tests/Network/BitTorrent/Internal/ProgressSpec.hs
index 32efbd7a..acbfd84c 100644
--- a/tests/Data/Torrent/ProgressSpec.hs
+++ b/tests/Network/BitTorrent/Internal/ProgressSpec.hs
@@ -1,9 +1,9 @@
 {-# OPTIONS -fno-warn-orphans #-}
-module Data.Torrent.ProgressSpec (spec) where
+module Network.BitTorrent.Internal.ProgressSpec (spec) where
 import Control.Applicative
 import Test.Hspec
 import Test.QuickCheck
-import Data.Torrent.Progress
+import Network.BitTorrent.Internal.Progress
 
 
 instance Arbitrary Progress where
diff --git a/tests/Network/BitTorrent/Tracker/MessageSpec.hs b/tests/Network/BitTorrent/Tracker/MessageSpec.hs
index c56afd2a..29854d58 100644
--- a/tests/Network/BitTorrent/Tracker/MessageSpec.hs
+++ b/tests/Network/BitTorrent/Tracker/MessageSpec.hs
@@ -16,13 +16,13 @@ import Data.Maybe
 import Test.Hspec
 import Test.QuickCheck
 
-import Data.Torrent.InfoHashSpec ()
-import Data.Torrent.ProgressSpec ()
-import Network.BitTorrent.Core.PeerIdSpec ()
-import Network.BitTorrent.Core.PeerAddrSpec ()
+import Data.TorrentSpec ()
+import Network.BitTorrent.Internal.ProgressSpec ()
+import Network.BitTorrent.Address ()
+import Network.BitTorrent.Address ()
 
 import Network.BitTorrent.Tracker.Message as Message
-import Network.BitTorrent.Core
+import Network.BitTorrent.Address
 
 
 --prop_bencode :: Eq a => BEncode a => a -> Bool
diff --git a/tests/Network/BitTorrent/Tracker/RPC/HTTPSpec.hs b/tests/Network/BitTorrent/Tracker/RPC/HTTPSpec.hs
index 65f58911..e928f917 100644
--- a/tests/Network/BitTorrent/Tracker/RPC/HTTPSpec.hs
+++ b/tests/Network/BitTorrent/Tracker/RPC/HTTPSpec.hs
@@ -5,7 +5,7 @@ import Data.Default
 import Data.List as L
 import Test.Hspec
 
-import Data.Torrent.Progress
+import Network.BitTorrent.Internal.Progress
 import Network.BitTorrent.Tracker.Message as Message
 import Network.BitTorrent.Tracker.RPC.HTTP
 
diff --git a/tests/Network/BitTorrent/Tracker/RPC/UDPSpec.hs b/tests/Network/BitTorrent/Tracker/RPC/UDPSpec.hs
index 8a1ffc01..1ec3bdb7 100644
--- a/tests/Network/BitTorrent/Tracker/RPC/UDPSpec.hs
+++ b/tests/Network/BitTorrent/Tracker/RPC/UDPSpec.hs
@@ -9,7 +9,7 @@ import Data.List as L
 import Data.Maybe
 import Test.Hspec
 
-import Network.BitTorrent.Core
+import Network.BitTorrent.Address
 import Network.BitTorrent.Tracker.Message as Message
 
 import Network.BitTorrent.Tracker.TestData
diff --git a/tests/Network/BitTorrent/Tracker/TestData.hs b/tests/Network/BitTorrent/Tracker/TestData.hs
index e0edba25..b95e2df4 100644
--- a/tests/Network/BitTorrent/Tracker/TestData.hs
+++ b/tests/Network/BitTorrent/Tracker/TestData.hs
@@ -12,7 +12,7 @@ import Data.Maybe
 import Data.String
 import Network.URI
 
-import Data.Torrent.InfoHash
+import Data.Torrent
 
 
 data TrackerEntry = TrackerEntry
diff --git a/tests/System/Torrent/FileMapSpec.hs b/tests/System/Torrent/FileMapSpec.hs
index 36632b3e..85180c0a 100644
--- a/tests/System/Torrent/FileMapSpec.hs
+++ b/tests/System/Torrent/FileMapSpec.hs
@@ -9,7 +9,7 @@ import System.FilePath
 import System.IO.Unsafe
 import Test.Hspec
 
-import Data.Torrent.Layout
+import Data.Torrent
 import System.Torrent.FileMap as FM
 
 
diff --git a/tests/System/Torrent/StorageSpec.hs b/tests/System/Torrent/StorageSpec.hs
index 30322545..b5e49078 100644
--- a/tests/System/Torrent/StorageSpec.hs
+++ b/tests/System/Torrent/StorageSpec.hs
@@ -7,9 +7,8 @@ import System.Directory
 import System.IO.Unsafe
 import Test.Hspec
 
-import Data.Torrent.Bitfield as BF
-import Data.Torrent.Layout
-import Data.Torrent.Piece
+import Data.Torrent
+import Network.BitTorrent.Exchange.Bitfield as BF
 import System.Torrent.Storage