10 files changed, 586 insertions, 43 deletions

diff --git a/src/Data/Torrent.hs b/src/Data/Torrent.hs
index c22ca189..8746fff5 100644
--- a/src/Data/Torrent.hs
+++ b/src/Data/Torrent.hs
@@ -100,7 +100,9 @@ module Data.Torrent
        , layoutInfo
        , pieceInfo
        , isPrivate
+#ifdef VERSION_bencoding
        , infoDictionary
+#endif
 
          -- * Torrent file
        , Torrent(..)
@@ -122,8 +124,10 @@ module Data.Torrent
        , typeTorrent
        , torrentExt
        , isTorrentPath
+#ifdef VERSION_bencoding
        , fromFile
        , toFile
+#endif
 
          -- * Magnet
          -- $magnet-link
@@ -150,8 +154,10 @@ import Control.Exception
 import Control.Lens
 import Control.Monad
 import Crypto.Hash.SHA1 as SHA1
+#ifdef VERSION_bencoding
 import Data.BEncode as BE
 import Data.BEncode.Types as BE
+#endif
 import Data.Bits
 #ifdef VERSION_bits_extras
 import Data.Bits.Extras
@@ -223,10 +229,12 @@ instance Hashable InfoHash where
   hashWithSalt s (InfoHash ih) = hashWithSalt s ih
   {-# INLINE hashWithSalt #-}
 
+#ifdef VERSION_bencoding
 -- | Convert to\/from raw bencoded string. (no encoding)
 instance BEncode InfoHash where
   toBEncode = toBEncode . getInfoHash
   fromBEncode be = InfoHash <$> fromBEncode be
+#endif
 
 -- | Convert to\/from raw bytestring. (no encoding)
 instance Serialize InfoHash where
@@ -321,7 +329,9 @@ shortHex = T.take 7 . longHex
 -- | Size of a file in bytes.
 type FileSize = FileOffset
 
+#ifdef VERSION_bencoding
 deriving instance BEncode  FileOffset
+#endif
 
 -- | Contain metainfo about one single file.
 data FileInfo a = FileInfo {
@@ -360,6 +370,7 @@ instance NFData a => NFData (FileInfo a) where
   rnf FileInfo {..} = rnf fiName
   {-# INLINE rnf #-}
 
+#ifdef VERSION_bencoding
 instance BEncode (FileInfo [BS.ByteString]) where
   toBEncode FileInfo {..} = toDict $
        "length" .=! fiLength
@@ -375,7 +386,9 @@ instance BEncode (FileInfo [BS.ByteString]) where
   {-# INLINE fromBEncode #-}
 
 type Put a = a -> BDict -> BDict
+#endif
 
+#ifdef VERSION_bencoding
 putFileInfoSingle :: Data.Torrent.Put (FileInfo BS.ByteString)
 putFileInfoSingle FileInfo {..} cont =
        "length" .=! fiLength
@@ -395,6 +408,7 @@ instance BEncode (FileInfo BS.ByteString) where
 
   fromBEncode = fromDict getFileInfoSingle
   {-# INLINE fromBEncode #-}
+#endif
 
 instance Pretty (FileInfo BS.ByteString) where
   pPrint FileInfo {..} =
@@ -447,6 +461,7 @@ instance NFData LayoutInfo where
 instance Default LayoutInfo where
   def = MultiFile [] ""
 
+#ifdef VERSION_bencoding
 getLayoutInfo :: BE.Get LayoutInfo
 getLayoutInfo = single <|> multi
   where
@@ -463,6 +478,7 @@ putLayoutInfo MultiFile  {..} = \ cont ->
 instance BEncode LayoutInfo where
   toBEncode   = toDict . (`putLayoutInfo` endDict)
   fromBEncode = fromDict getLayoutInfo
+#endif
 
 instance Pretty LayoutInfo where
   pPrint SingleFile {..} = pPrint liFile
@@ -637,7 +653,11 @@ hashPiece Piece {..} = SHA1.hashlazy pieceData
 
 -- | A flat array of SHA1 hash for each piece.
 newtype HashList = HashList { unHashList :: BS.ByteString }
-  deriving (Show, Read, Eq, BEncode, Typeable)
+  deriving ( Show, Read, Eq, Typeable
+#ifdef VERSION_bencoding
+           , BEncode
+#endif
+           )
 
 -- | Empty hash list.
 instance Default HashList where
@@ -665,6 +685,7 @@ instance Default PieceInfo where
   def = PieceInfo 1 def
 
 
+#ifdef VERSION_bencoding
 putPieceInfo :: Data.Torrent.Put PieceInfo
 putPieceInfo PieceInfo {..} cont =
        "piece length" .=! piPieceLength
@@ -679,6 +700,7 @@ getPieceInfo = do
 instance BEncode PieceInfo where
   toBEncode   = toDict . (`putPieceInfo` endDict)
   fromBEncode = fromDict getPieceInfo
+#endif
 
 -- | Hashes are omitted.
 instance Pretty PieceInfo where
@@ -750,6 +772,13 @@ instance Hashable InfoDict where
   hashWithSalt = Hashable.hashUsing idInfoHash
   {-# INLINE hashWithSalt #-}
 
+-- | Hash lazy bytestring using SHA1 algorithm.
+hashLazyIH :: BL.ByteString -> InfoHash
+hashLazyIH = either (const (error msg)) id . safeConvert . SHA1.hashlazy
+  where
+    msg = "Infohash.hash: impossible: SHA1 is always 20 bytes long"
+
+#ifdef VERSION_bencoding
 -- | Empty info dictionary with zero-length content.
 instance Default InfoDict where
   def = infoDictionary def def False
@@ -767,12 +796,6 @@ putPrivate :: Bool -> BDict -> BDict
 putPrivate False = id
 putPrivate True  = \ cont -> "private" .=! True .: cont
 
--- | Hash lazy bytestring using SHA1 algorithm.
-hashLazyIH :: BL.ByteString -> InfoHash
-hashLazyIH = either (const (error msg)) id . safeConvert . SHA1.hashlazy
-  where
-    msg = "Infohash.hash: impossible: SHA1 is always 20 bytes long"
-
 instance BEncode InfoDict where
   toBEncode InfoDict {..} = toDict $
       putLayoutInfo idLayoutInfo   $
@@ -786,6 +809,7 @@ instance BEncode InfoDict where
                   <*> getPrivate
     where
       ih = hashLazyIH (BE.encode dict)
+#endif
 
 ppPrivacy :: Bool -> Doc
 ppPrivacy privacy = "Privacy: " <> if privacy then "private" else "public"
@@ -868,6 +892,7 @@ makeLensesFor
 instance NFData Torrent where
   rnf Torrent {..} = rnf tInfoDict
 
+#ifdef VERSION_bencoding
 -- TODO move to bencoding
 instance BEncode URI where
   toBEncode uri = toBEncode (BC.pack (uriToString id uri ""))
@@ -918,6 +943,7 @@ instance BEncode Torrent where
             <*>? "publisher"
             <*>? "publisher-url"
             <*>? "signature"
+#endif
 
 (<:>) :: Doc -> Doc -> Doc
 name <:>   v       = name <> ":" <+> v
@@ -949,9 +975,11 @@ instance Pretty Torrent where
         "Publisher URL" <:>? ((text . show) <$> tPublisherURL) $$
         "Signature"     <:>? ((text . show) <$> tSignature)
 
+#ifdef VERSION_bencoding
 -- | No files, no trackers, no nodes, etc...
 instance Default Torrent where
   def = nullTorrent def
+#endif
 
 -- | A simple torrent contains only required fields.
 nullTorrent :: InfoDict -> Torrent
@@ -971,6 +999,7 @@ torrentExt = "torrent"
 isTorrentPath :: FilePath -> Bool
 isTorrentPath filepath = takeExtension filepath == extSeparator : torrentExt
 
+#ifdef VERSION_bencoding
 -- | Read and decode a .torrent file.
 fromFile :: FilePath -> IO Torrent
 fromFile filepath = do
@@ -982,6 +1011,7 @@ fromFile filepath = do
 -- | Encode and write a .torrent file.
 toFile :: FilePath -> Torrent -> IO ()
 toFile filepath = BL.writeFile filepath . BE.encode
+#endif
 
 {-----------------------------------------------------------------------
 --  URN
diff --git a/src/Data/Tox.hs b/src/Data/Tox.hs
new file mode 100644
index 00000000..448b39eb
--- /dev/null
+++ b/src/Data/Tox.hs
@@ -0,0 +1,196 @@
+{-# LANGUAGE DeriveDataTypeable #-}
+{-# LANGUAGE DeriveGeneric      #-}
+{-# LANGUAGE PatternSynonyms    #-}
+{-# LANGUAGE RecordWildCards    #-}
+{-# LANGUAGE TupleSections      #-}
+{-# LANGUAGE UnboxedTuples      #-}
+module Data.Tox where
+
+import Data.ByteString (ByteString)
+import Data.Data (Data)
+import Data.Word
+import Data.LargeWord
+import Data.IP
+import Data.Serialize
+import Network.BitTorrent.Address () -- Serialize IP
+import GHC.Generics (Generic)
+import Network.Socket
+
+type Key32   = Word256 -- 32 byte key
+type Nonce8  = Word64  -- 8 bytes
+type Nonce24 = Word192 -- 24 bytes
+type NodeId  = Word256 -- 32 bytes (mainline uses only 20-byte node IDs)
+
+
+data NodeFormat = NodeFormat
+    { nodePublicKey :: Key32 -- 32 byte public key
+    , nodeIsTCP :: Bool -- This has no analog in mainline NodeInfo structure
+    , nodeIP :: IP -- IPv4 or IPv6  address
+    , nodePort :: PortNumber
+    }
+ deriving (Eq, Ord, Show)
+
+encodeFamily :: (Family, SocketType) -> Word8
+encodeFamily (AF_INET   , Datagram) = 2
+encodeFamily (AF_INET6  , Datagram) = 10
+encodeFamily (AF_INET   , Stream  ) = 130
+encodeFamily (AF_INET6  , Stream  ) = 138
+encodeFamily _ = error "Unsupported protocol"
+
+newtype MessageType = MessageType Word8
+ deriving (Eq, Ord, Show, Read)
+
+instance Serialize MessageType where
+    put (MessageType b) = put b
+    get = MessageType <$> get
+
+pattern Ping      = MessageType 0
+pattern Pong      = MessageType 1
+pattern GetNodes  = MessageType 2
+pattern SendNodes = MessageType 4
+{-
+ #define NET_PACKET_PING_REQUEST    0   /* Ping request packet ID. */
+ #define NET_PACKET_PING_RESPONSE   1   /* Ping response packet ID. */
+ #define NET_PACKET_GET_NODES       2   /* Get nodes request packet ID. */
+ #define NET_PACKET_SEND_NODES_IPV6 4   /* Send nodes response packet ID for other addresses. */
+ #define NET_PACKET_COOKIE_REQUEST  24  /* Cookie request packet */
+ #define NET_PACKET_COOKIE_RESPONSE 25  /* Cookie response packet */
+ #define NET_PACKET_CRYPTO_HS       26  /* Crypto handshake packet */
+ #define NET_PACKET_CRYPTO_DATA     27  /* Crypto data packet */
+ #define NET_PACKET_CRYPTO          32  /* Encrypted data packet ID. */
+ #define NET_PACKET_LAN_DISCOVERY   33  /* LAN discovery packet ID. */
+
+ /* See:  docs/Prevent_Tracking.txt and onion.{c, h} */
+ #define NET_PACKET_ONION_SEND_INITIAL 128
+ #define NET_PACKET_ONION_SEND_1 129
+ #define NET_PACKET_ONION_SEND_2 130
+
+ #define NET_PACKET_ANNOUNCE_REQUEST 131
+ #define NET_PACKET_ANNOUNCE_RESPONSE 132
+ #define NET_PACKET_ONION_DATA_REQUEST 133
+ #define NET_PACKET_ONION_DATA_RESPONSE 134
+
+ #define NET_PACKET_ONION_RECV_3 140
+ #define NET_PACKET_ONION_RECV_2 141
+ #define NET_PACKET_ONION_RECV_1 142
+ -}
+
+
+-- FIXME Orphan Serialize intance for large words
+instance (Serialize a, Serialize b) => Serialize (LargeKey a b) where
+   put (LargeKey lo hi) = put hi >> put lo
+   get = flip LargeKey <$> get <*> get
+
+-- | Use with 'PingPayload', 'GetNodesPayload', or 'SendNodesPayload'
+data Message a = Message
+    { msgType    :: MessageType
+    , msgClient  :: NodeId
+    , msgNonce   :: Nonce24
+    , msgPayload :: a
+    }
+ deriving (Show, Generic)
+
+isQuery :: Message a -> Bool
+isQuery (Message { msgType = SendNodes })                  = False
+isQuery (Message { msgType = MessageType typ }) | even typ = True
+isQuery _                                                  = False
+
+isResponse :: Message a -> Bool
+isResponse m = not (isQuery m)
+
+isError :: Message a -> Bool
+isError _ = False
+
+instance Serialize a => Serialize (Message a) where -- TODO TOX
+
+data PingPayload = PingPayload
+    { isPong :: Bool
+    , pingId :: Nonce8
+    }
+
+data GetNodesPayload = GetNodesPayload
+    { nodesForWho :: NodeId
+    , nodesNonce :: Nonce8
+    }
+
+data SendNodesPayload = SendNodesPayload
+
+-- From: docs/updates/DHT.md
+--
+-- Node format:
+-- [uint8_t family (2 == IPv4, 10 == IPv6, 130 == TCP IPv4, 138 == TCP IPv6)]
+-- [ip (in network byte order), length=4 bytes if ipv4, 16 bytes if ipv6]
+-- [port (in network byte order), length=2 bytes]
+-- [char array (node_id), length=32 bytes]
+--
+-- see also: DHT.h (pack_nodes() and unpack_nodes())
+instance Serialize NodeFormat where
+
+    get = do
+        typ <- get :: Get Word8
+        (ip,istcp) <-
+            case typ :: Word8 of
+                2 -> (,False) . IPv4 <$> get
+                130 -> (,True) . IPv4 <$> get
+                10 -> (,False) . IPv6 <$> get
+                138 -> (,True) . IPv6 <$> get
+                _ -> fail "Unsupported type of Tox node_format structure"
+        port <- get
+        pubkey <- get
+        return $ NodeFormat { nodeIsTCP     = istcp
+                            , nodeIP        = ip
+                            , nodePort      = port
+                            , nodePublicKey = pubkey
+                            }
+
+    put (NodeFormat{..}) = do
+        put $ case (# nodeIP, nodeIsTCP #) of
+                (# IPv4 _, False #) -> 2
+                (# IPv4 _, True  #) -> 130
+                (# IPv6 _, False #) -> 10
+                (# IPv6 _, True  #) -> 138 :: Word8
+        put nodeIP
+        put nodePort
+        put nodePublicKey
+
+-- Note: the char array is a public key, the 32-bytes is provided by libsodium-dev
+-- in /usr/include/sodium/crypto_box.h as the symbol crypto_box_PUBLICKEYBYTES
+-- but toxcore/crypto_core.c will fail to compile if it is not 32.
+
+
+-- Ping(Request and response):
+--
+-- [byte with value: 00 for request, 01 for response]
+-- [char array (client node_id), length=32 bytes]
+-- [random 24 byte nonce]
+-- [Encrypted with the nonce and private key of the sender:
+--   [1 byte type (0 for request, 1 for response)]
+--   [random 8 byte (ping_id)]
+--   ]
+--
+-- ping_id = a random integer, the response must contain the exact same number as the request
+
+
+-- Get nodes (Request):
+--
+-- [byte with value: 02]
+-- [char array (client node_id), length=32 bytes]
+-- [random 24 byte nonce]
+-- [Encrypted with the nonce and private key of the sender:
+--   [char array: requested_node_id (node_id of which we want the ip), length=32 bytes]
+--   [Sendback data (must be sent back unmodified by in the response), length=8 bytes]
+--   ]
+--
+-- Valid replies: a send_nodes packet
+
+-- Send_nodes (response (for all addresses)):
+--
+-- [byte with value: 04]
+-- [char array  (client node_id), length=32 bytes]
+-- [random 24 byte nonce]
+-- [Encrypted with the nonce and private key of the sender:
+--   [uint8_t number of nodes in this packet]
+--   [Nodes in node format, length=?? * (number of nodes (maximum of 4 nodes)) bytes]
+--   [Sendback data, length=8 bytes]
+--   ]
+
diff --git a/src/Network/BitTorrent/Address.hs b/src/Network/BitTorrent/Address.hs
index a8e12b35..2132f8f9 100644
--- a/src/Network/BitTorrent/Address.hs
+++ b/src/Network/BitTorrent/Address.hs
@@ -91,8 +91,10 @@ module Network.BitTorrent.Address
 import Control.Applicative
 import Control.Monad
 import Control.Exception (onException)
+#ifdef VERSION_bencoding
 import Data.BEncode as BE
 import Data.BEncode.BDict (BKey)
+#endif
 import Data.Bits
 import qualified Data.ByteString as BS
 import qualified Data.ByteString.Internal as BS
@@ -204,7 +206,11 @@ instance Address a => Address (PeerAddr a) where
 
 -- | Peer identifier is exactly 20 bytes long bytestring.
 newtype PeerId = PeerId { getPeerId :: ByteString }
-  deriving (Show, Eq, Ord, BEncode, Typeable)
+  deriving ( Show, Eq, Ord, Typeable
+#ifdef VERSION_bencoding
+           , BEncode
+#endif
+           )
 
 peerIdLen :: Int
 peerIdLen = 20
@@ -369,6 +375,7 @@ genPeerId = azureusStyle defaultClientId defaultVersionNumber <$> timestamp
 --  Port number
 -----------------------------------------------------------------------}
 
+#ifdef VERSION_bencoding
 instance BEncode PortNumber where
   toBEncode   = toBEncode    .  fromEnum
   fromBEncode = fromBEncode >=> portNumber
@@ -378,6 +385,7 @@ instance BEncode PortNumber where
         | 0 <= n && n <= fromIntegral (maxBound :: Word16)
         = pure $ fromIntegral n
         | otherwise = decodingError $ "PortNumber: " ++ show n
+#endif
 
 instance Serialize PortNumber where
   get = fromIntegral <$> getWord16be
@@ -417,6 +425,7 @@ deriving instance Typeable IP
 deriving instance Typeable IPv4
 deriving instance Typeable IPv6
 
+#ifdef VERSION_bencoding
 ipToBEncode :: Show i => i -> BValue
 ipToBEncode ip = BString $ BS8.pack $ show ip
 {-# INLINE ipToBEncode #-}
@@ -444,6 +453,7 @@ instance BEncode IPv6 where
   {-# INLINE toBEncode #-}
   fromBEncode = ipFromBEncode
   {-# INLINE fromBEncode #-}
+#endif
 
 -- | 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
@@ -508,6 +518,7 @@ data PeerAddr a = PeerAddr
   , peerPort :: {-# UNPACK #-} !PortNumber
   } deriving (Show, Eq, Ord, Typeable, Functor)
 
+#ifdef VERSION_bencoding
 peer_ip_key, peer_id_key, peer_port_key :: BKey
 peer_ip_key   = "ip"
 peer_id_key   = "peer id"
@@ -527,6 +538,7 @@ instance (Typeable a, BEncode a) => BEncode (PeerAddr a) where
              <*>! peer_port_key
     where
       peerAddr = flip PeerAddr
+#endif
 
 -- | The tracker's 'compact peer list' compatible encoding. The
 -- 'peerId' is always 'Nothing'.
@@ -642,7 +654,12 @@ peerSocket socketType pa = do
 --   Normally, /this/ node id should be saved between invocations
 --   of the client software.
 newtype NodeId = NodeId ByteString
-  deriving (Show, Eq, Ord, BEncode, Typeable)
+  deriving (Show, Eq, Ord, Typeable
+#ifdef VERSION_bencoding
+           , BEncode
+#endif
+           )
+
 
 nodeIdSize :: Int
 nodeIdSize = 20
@@ -771,12 +788,14 @@ instance Serialize a => Serialize (NodeAddr a) where
   put NodeAddr {..} = put nodeHost >> put nodePort
   {-# INLINE put #-}
 
+#ifdef VERSION_bencoding
 -- | 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 #-}
+#endif
 
 instance Hashable a => Hashable (NodeAddr a) where
   hashWithSalt s NodeAddr {..} = hashWithSalt s (nodeHost, nodePort)
diff --git a/src/Network/BitTorrent/DHT/Message.hs b/src/Network/BitTorrent/DHT/Message.hs
index 1f835fa6..44dc9b2f 100644
--- a/src/Network/BitTorrent/DHT/Message.hs
+++ b/src/Network/BitTorrent/DHT/Message.hs
@@ -55,6 +55,7 @@
 --   For Kamelia messages see original Kademlia paper:
 --   <http://pdos.csail.mit.edu/~petar/papers/maymounkov-kademlia-lncs.pdf>
 --
+{-# LANGUAGE CPP #-}
 {-# LANGUAGE DeriveDataTypeable #-}
 {-# LANGUAGE FlexibleInstances  #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
@@ -73,6 +74,8 @@ module Network.BitTorrent.DHT.Message
        , FindNode (..)
        , NodeFound (..)
 
+
+#ifdef VERSION_bencoding
          -- ** get_peers
        , PeerList
        , GetPeers (..)
@@ -81,12 +84,23 @@ module Network.BitTorrent.DHT.Message
          -- ** announce_peer
        , Announce  (..)
        , Announced (..)
+#endif
        ) where
 
 import Control.Applicative
 import Data.Bool
+#ifdef VERSION_bencoding
 import Data.BEncode as BE
 import Data.BEncode.BDict as BDict
+import Network.BitTorrent.Address
+#else
+import qualified Data.Tox as Tox
+import Data.Tox (NodeId)
+import Data.Word
+import Control.Monad
+import Network.KRPC.Method
+import Network.BitTorrent.Address hiding (NodeId)
+#endif
 import Data.ByteString (ByteString)
 import Data.List as L
 import Data.Monoid
@@ -97,7 +111,6 @@ import Network.KRPC
 import Data.Maybe
 
 import Data.Torrent (InfoHash)
-import Network.BitTorrent.Address
 import Network.BitTorrent.DHT.Token
 import Network.KRPC ()
 
@@ -105,6 +118,10 @@ import Network.KRPC ()
 -- envelopes
 -----------------------------------------------------------------------}
 
+#ifndef VERSION_bencoding
+type BKey = ByteString
+#endif
+
 node_id_key :: BKey
 node_id_key = "id"
 
@@ -112,6 +129,7 @@ read_only_key :: BKey
 read_only_key = "ro"
 
 
+#ifdef VERSION_bencoding
 -- | All queries have an \"id\" key and value containing the node ID
 -- of the querying node.
 data Query a = Query
@@ -134,7 +152,11 @@ instance BEncode a => BEncode (Query a) where
     Query <$> fromDict (field (req node_id_key)) v
           <*> fromDict (fromMaybe False <$>? read_only_key) v
           <*> fromBEncode v
+#else
+data Query a = Query a
+#endif
 
+#ifdef VERSION_bencoding
 -- | All responses have an \"id\" key and value containing the node ID
 -- of the responding node.
 data Response a = Response
@@ -150,7 +172,9 @@ instance BEncode a => BEncode (Response a) where
   fromBEncode b = fromQuery <$> fromBEncode b
     where
       fromQuery (Query nid _ a) = Response nid a
-
+#else
+data Response a = Response a
+#endif
 
 {-----------------------------------------------------------------------
 -- ping method
@@ -158,16 +182,45 @@ instance BEncode a => BEncode (Response a) where
 
 -- | The most basic query is a ping. Ping query is used to check if a
 -- quered node is still alive.
+#ifdef VERSION_bencoding
 data Ping = Ping
+#else
+data Ping = Ping Tox.Nonce8
+#endif
   deriving (Show, Eq, Typeable)
 
+#ifdef VERSION_bencoding
 instance BEncode Ping where
   toBEncode Ping = toDict endDict
   fromBEncode _  = pure Ping
+#else
+instance Serialize (Query Ping) where
+    get = do
+        b <- get
+        when ( (b::Word8) /= 0) $ fail "Bad ping request"
+        nonce <- get
+        return $ Query (Ping nonce)
+    put (Query (Ping nonce)) = do
+        put (0 :: Word8)
+        put nonce
+instance Serialize (Response Ping) where
+    get = do
+        b <- get
+        when ( (b::Word8) /= 1) $ fail "Bad ping response"
+        nonce <- get
+        return $ Response (Ping nonce)
+    put (Response (Ping nonce)) = do
+        put (1 :: Word8)
+        put nonce
+#endif
 
 -- | \"q\" = \"ping\"
 instance KRPC (Query Ping) (Response Ping) where
+#ifdef VERSION_bencoding
   method = "ping"
+#else
+  method = Method Tox.Ping -- response: Tox.Pong
+#endif
 
 {-----------------------------------------------------------------------
 -- find_node method
@@ -175,21 +228,41 @@ instance KRPC (Query Ping) (Response Ping) where
 
 -- | Find node is used to find the contact information for a node
 -- given its ID.
+#ifdef VERSION_bencoding
 newtype FindNode = FindNode NodeId
+#else
+data FindNode = FindNode NodeId Tox.Nonce8 -- Tox: Get Nodes
+#endif
   deriving (Show, Eq, Typeable)
 
 target_key :: BKey
 target_key = "target"
 
+#ifdef VERSION_bencoding
 instance BEncode FindNode where
   toBEncode (FindNode nid) = toDict   $ target_key .=! nid .: endDict
   fromBEncode              = fromDict $ FindNode  <$>! target_key
+#else
+instance Serialize (Query FindNode) where
+    get = do
+        nid <- get
+        nonce <- get
+        return $ Query (FindNode nid nonce)
+    put (Query (FindNode nid nonce)) = do
+        put nid
+        put nonce
+#endif
 
 -- | When a node receives a 'FindNode' query, it should respond with a
 -- the compact node info for the target node or the K (8) closest good
 -- nodes in its own routing table.
 --
+#ifdef VERSION_bencoding
 newtype NodeFound ip = NodeFound [NodeInfo ip]
+#else
+data NodeFound ip = NodeFound [Tox.NodeFormat] Tox.Nonce8
+#endif
+-- Tox: send_nodes
   deriving (Show, Eq, Typeable)
 
 nodes_key :: BKey
@@ -200,6 +273,7 @@ from4 :: forall s. Address s => NodeInfo IPv4 -> Either String (NodeInfo s)
 from4 n = maybe (Left "Error converting IPv4") Right
                     $ traverse (fromAddr :: IPv4 -> Maybe s) n
 
+#ifdef VERSION_bencoding
 binary :: Serialize a => BKey -> BE.Get [a]
 binary k = field (req k) >>= either (fail . format) return .
     runGet (many get)
@@ -213,12 +287,31 @@ instance Address ip => BEncode (NodeFound ip) where
 
   -- TODO: handle IPv6 by reading the "nodes6" key (see bep 32)
   fromBEncode bval = NodeFound <$> (traverse from4 =<< fromDict (binary nodes_key) bval)
+#else
+instance Serialize (Response (NodeFound ip)) where
+    get = do
+        count <- get :: Get Word8
+        nodes <- sequence $ replicate (fromIntegral count) get
+        nonce <- get :: Get Tox.Nonce8
+        return $ Response $ NodeFound nodes nonce
+
+    put (Response (NodeFound nodes nonce)) = do
+        put (fromIntegral (length nodes) :: Word8)
+        mapM_ put nodes
+        put nonce
+
+#endif
 
 -- | \"q\" == \"find_node\"
 instance (Address ip, Typeable ip)
       => KRPC (Query FindNode) (Response (NodeFound ip)) where
+#ifdef VERSION_bencoding
   method = "find_node"
+#else
+  method = Method Tox.GetNodes -- response: Tox.SendNodes
+#endif
 
+#ifdef VERSION_bencoding
 {-----------------------------------------------------------------------
 -- get_peers method
 -----------------------------------------------------------------------}
@@ -354,3 +447,6 @@ instance BEncode Announced where
 -- | \"q" = \"announce\"
 instance KRPC (Query Announce) (Response Announced) where
   method = "announce_peer"
+
+-- endif VERSION_bencoding
+#endif
diff --git a/src/Network/BitTorrent/DHT/Query.hs b/src/Network/BitTorrent/DHT/Query.hs
index 5345f8b1..c7e48920 100644
--- a/src/Network/BitTorrent/DHT/Query.hs
+++ b/src/Network/BitTorrent/DHT/Query.hs
@@ -96,7 +96,10 @@ import qualified Network.BitTorrent.DHT.Search as Search
 
 nodeHandler :: Address ip => KRPC (Query a) (Response b)
            => (NodeAddr ip -> a -> DHT ip b) -> NodeHandler ip
-nodeHandler action = handler $ \ sockAddr (Query remoteId read_only q) -> do
+nodeHandler action = handler $ \ sockAddr qry -> do
+  let remoteId  = queringNodeId qry
+      read_only = queryIsReadOnly qry
+      q         = queryParams qry
   case fromSockAddr sockAddr of
     Nothing    -> throwIO BadAddress
     Just naddr -> do
@@ -119,6 +122,7 @@ findNodeH :: Address ip => NodeHandler ip
 findNodeH = nodeHandler $ \ _ (FindNode nid) -> do
   NodeFound <$> getClosest nid
 
+#ifdef VERSION_bencoding
 -- | Default 'GetPeers' handler.
 getPeersH :: Ord ip => Address ip => NodeHandler ip
 getPeersH = nodeHandler $ \ naddr (GetPeers ih) -> do
@@ -141,6 +145,11 @@ announceH = nodeHandler $ \ naddr @ NodeAddr {..} (Announce {..}) -> do
 -- | Includes all default query handlers.
 defaultHandlers :: Ord ip => Address ip => [NodeHandler ip]
 defaultHandlers = [pingH, findNodeH, getPeersH, announceH]
+#else
+-- | Includes all default query handlers.
+defaultHandlers :: Ord ip => Address ip => [NodeHandler ip]
+defaultHandlers = [pingH, findNodeH]
+#endif
 
 {-----------------------------------------------------------------------
 --  Basic queries
@@ -165,6 +174,7 @@ findNodeQ key NodeInfo {..} = do
     <> T.pack (L.unlines $ L.map ((' ' :) . show . pPrint) closest)
   return $ Right closest
 
+#ifdef VERSION_bencoding
 getPeersQ :: Address ip => InfoHash -> Iteration ip PeerAddr
 getPeersQ topic NodeInfo {..} = do
   GotPeers {..} <- GetPeers topic <@> nodeAddr
@@ -184,6 +194,7 @@ announceQ ih p NodeInfo {..} = do
     Right _ -> do -- TODO *probably* add to peer cache
       Announced <- Announce False ih Nothing p grantedToken <@> nodeAddr
       return (Right [nodeAddr])
+#endif
 
 {-----------------------------------------------------------------------
 --  Iterative queries
diff --git a/src/Network/BitTorrent/DHT/Session.hs b/src/Network/BitTorrent/DHT/Session.hs
index bad783a5..82926b28 100644
--- a/src/Network/BitTorrent/DHT/Session.hs
+++ b/src/Network/BitTorrent/DHT/Session.hs
@@ -55,6 +55,7 @@ module Network.BitTorrent.DHT.Session
        , getTable
        , getClosest
 
+#ifdef VERSION_bencoding
          -- ** Peer storage
        , insertPeer
        , getPeerList
@@ -64,6 +65,7 @@ module Network.BitTorrent.DHT.Session
        , savePeerStore
        , mergeSavedPeers
        , allPeers
+#endif
 
          -- ** Messaging
        , queryParallel
@@ -482,6 +484,7 @@ getTimestamp = do
   return $ utcTimeToPOSIXSeconds utcTime
 
 
+#ifdef VERSION_bencoding
 -- | Prepare result for 'get_peers' query.
 --
 --   This operation use 'getClosest' as failback so it may block.
@@ -503,6 +506,8 @@ deleteTopic ih p = do
   var <- asks announceInfo
   liftIO $ atomically $ modifyTVar' var (S.delete (ih, p))
 
+#endif
+
 {-----------------------------------------------------------------------
 -- Messaging
 -----------------------------------------------------------------------}
diff --git a/src/Network/BitTorrent/DHT/Token.hs b/src/Network/BitTorrent/DHT/Token.hs
index 3f71aabe..4c930cbc 100644
--- a/src/Network/BitTorrent/DHT/Token.hs
+++ b/src/Network/BitTorrent/DHT/Token.hs
@@ -17,7 +17,7 @@
 -- must be accepted for a reasonable amount of time after they have
 -- been distributed.
 --
-{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving, CPP #-}
 module Network.BitTorrent.DHT.Token
        ( -- * Token
          Token
@@ -38,7 +38,9 @@ module Network.BitTorrent.DHT.Token
        ) where
 
 import Control.Monad.State
+#ifdef VERSION_bencoding
 import Data.BEncode (BEncode)
+#endif
 import Data.ByteString as BS
 import Data.ByteString.Char8 as B8
 import Data.ByteString.Lazy as BL
@@ -57,7 +59,11 @@ import Network.BitTorrent.Address
 
 -- | An opaque value.
 newtype Token = Token BS.ByteString
-  deriving (Eq, BEncode, IsString)
+  deriving ( Eq, IsString
+#ifdef VERSION_bencoding
+           , BEncode
+#endif
+           )
 
 instance Show Token where
     show (Token bs) = B8.unpack $ Base16.encode bs
diff --git a/src/Network/KRPC/Manager.hs b/src/Network/KRPC/Manager.hs
index 66de6548..e7f0563b 100644
--- a/src/Network/KRPC/Manager.hs
+++ b/src/Network/KRPC/Manager.hs
@@ -55,9 +55,13 @@ import Control.Monad
 import Control.Monad.Logger
 import Control.Monad.Reader
 import Control.Monad.Trans.Control
+#ifdef VERSION_bencoding
 import Data.BEncode as BE
 import Data.BEncode.Internal as BE
 import Data.BEncode.Pretty (showBEncode)
+#else
+import qualified Data.Tox as Tox
+#endif
 import qualified Data.ByteString.Base16 as Base16
 import Data.ByteString as BS
 import Data.ByteString.Char8 as BC
@@ -67,6 +71,7 @@ import Data.IORef
 import Data.List as L
 import Data.Map as M
 import Data.Monoid
+import Data.Serialize as S
 import Data.Text as T
 import Data.Text.Encoding as T
 import Data.Tuple
@@ -128,10 +133,10 @@ type KResult = Either KError KResponse
 
 type TransactionCounter = IORef Int
 type CallId             = (TransactionId, SockAddr)
-type CallRes            = MVar (BValue, KResult)
+type CallRes            = MVar (KQueryArgs, KResult) -- (raw response, decoded response)
 type PendingCalls       = IORef (Map CallId CallRes)
 
-type HandlerBody h = SockAddr -> BValue -> h (BE.Result BValue)
+type HandlerBody h = SockAddr -> KQueryArgs -> h (Either String KQueryArgs)
 
 -- | Handler is a function which will be invoked then some /remote/
 -- node querying /this/ node.
@@ -223,8 +228,13 @@ withManager opts addr hs = bracket (newManager opts addr hs) closeManager
 -- TODO prettify log messages
 querySignature :: MethodName -> TransactionId -> SockAddr -> Text
 querySignature name transaction addr = T.concat
+#ifdef VERSION_bencoding
   [  "&", T.decodeUtf8 name
   , " #", T.decodeUtf8 (Base16.encode transaction) -- T.decodeUtf8 transaction
+#else
+  [  "&", T.pack (show name)
+  , " #", T.decodeUtf8 (Base16.encode $ S.encode transaction)
+#endif
   , " @", T.pack (show addr)
   ]
 
@@ -243,14 +253,24 @@ data QueryFailure
 
 instance Exception QueryFailure
 
+#ifdef VERSION_bencoding
 sendMessage :: MonadIO m => BEncode a => Socket -> SockAddr -> a -> m ()
 sendMessage sock addr a = do
   liftIO $ sendManyTo sock (BL.toChunks (BE.encode a)) addr
+#else
+sendMessage :: MonadIO m => Socket -> SockAddr -> BC.ByteString -> m ()
+sendMessage sock addr a = do
+  liftIO $ sendManyTo sock [a] addr
+#endif
 
 genTransactionId :: TransactionCounter -> IO TransactionId
 genTransactionId ref = do
   cur <- atomicModifyIORef' ref $ \ cur -> (succ cur, cur)
+#ifdef VERSION_bencoding
   return $ BC.pack (show cur)
+#else
+  return $ either (error "failed to create TransactionId") id $ S.decode $ BC.pack (L.take 24 $ show cur ++ L.repeat ' ')
+#endif
 
 -- | How many times 'query' call have been performed.
 getQueryCount :: MonadKRPC h m => m Int
@@ -274,8 +294,13 @@ unregisterQuery cid ref = do
 
 
 -- (sendmsg EINVAL)
+#ifdef VERSION_bencoding
 sendQuery :: BEncode a => Socket -> SockAddr -> a -> IO ()
 sendQuery sock addr q = handle sockError $ sendMessage sock addr q
+#else
+sendQuery :: Serialize a => Socket -> SockAddr -> a -> IO ()
+sendQuery sock addr q = handle sockError $ sendMessage sock addr (S.encode q)
+#endif
   where
     sockError :: IOError -> IO ()
     sockError _ = throwIO SendFailed
@@ -295,11 +320,11 @@ query' addr params = queryK addr params (const (,))
 -- | Enqueue a query, but give us the complete BEncoded content sent by the
 -- remote Node.  This is useful for handling extensions that this library does
 -- not otherwise support.
-queryRaw :: forall h m a b. (MonadKRPC h m, KRPC a b) => SockAddr -> a -> m (b, BValue)
+queryRaw :: forall h m a b. (MonadKRPC h m, KRPC a b) => SockAddr -> a -> m (b, KQueryArgs)
 queryRaw addr params = queryK addr params (\raw x _ -> (x,raw))
 
 queryK :: forall h m a b x. (MonadKRPC h m, KRPC a b) =>
-    SockAddr -> a -> (BValue -> b -> Maybe ReflectedIP -> x) -> m x
+    SockAddr -> a -> (KQueryArgs -> b -> Maybe ReflectedIP -> x) -> m x
 queryK addr params kont = do
   Manager {..} <- getManager
   tid <- liftIO $ genTransactionId transactionCounter
@@ -310,17 +335,29 @@ queryK addr params kont = do
   mres <- liftIO $ do
     ares <- registerQuery (tid, addr) pendingCalls
 
+#ifdef VERSION_bencoding
     let q = KQuery (toBEncode params) (methodName queryMethod) tid
+#else
+    let q = Tox.Message (methodName queryMethod) cli tid params
+        cli = error "TODO TOX client node id"
+#endif
     sendQuery sock addr q
       `onException` unregisterQuery (tid, addr) pendingCalls
 
     timeout (optQueryTimeout options * 10 ^ (6 :: Int)) $ do
-      (raw,res) <- readMVar ares
+      (raw,res) <- readMVar ares -- MVar (KQueryArgs, KResult)
       case res of
+#ifdef VERSION_bencoding
         Left  (KError   c m _) -> throwIO $ QueryFailed c (T.decodeUtf8 m)
         Right (KResponse {..}) ->
           case fromBEncode respVals of
             Right r -> pure $ kont raw r respIP
+#else
+        Left  _                  -> throwIO $ QueryFailed GenericError "TODO: TOX ERROR"
+        Right (Tox.Message {..}) ->
+          case S.decode msgPayload of
+            Right r -> pure $ kont raw r Nothing
+#endif
             Left  e -> throwIO $ QueryFailed ProtocolError (T.pack e)
 
   case mres of
@@ -377,51 +414,87 @@ handler body = (name, wrapper)
   where
     Method name = method :: Method a b
     wrapper addr args =
+#ifdef VERSION_bencoding
       case fromBEncode args of
+#else
+      case S.decode args of
+#endif
         Left  e -> return $ Left e
         Right a -> do
           r <- body addr a
+#ifdef VERSION_bencoding
           return $ Right $ toBEncode r
+#else
+          return $ Right $ S.encode r
+#endif
 
 runHandler :: MonadKRPC h m
            => HandlerBody h -> SockAddr -> KQuery -> m KResult
-runHandler h addr KQuery {..} = Lifted.catches wrapper failbacks
+runHandler h addr m = Lifted.catches wrapper failbacks
   where
-    signature = querySignature queryMethod queryId addr
+    signature = querySignature (queryMethod m) (queryId m) addr
 
     wrapper = do
       $(logDebugS) "handler.quered" signature
-      result <- liftHandler (h addr queryArgs)
+      result <- liftHandler (h addr (queryArgs m))
 
       case result of
         Left msg -> do
           $(logDebugS) "handler.bad_query" $ signature <> " !" <> T.pack msg
-          return $ Left $ KError ProtocolError (BC.pack msg) queryId
+#ifdef VERSION_bencoding
+          return $ Left $ KError ProtocolError (BC.pack msg) (queryId m)
+#else
+          return $ Left $ decodeError "TODO TOX ProtocolError" (queryId m)
+#endif
 
-        Right a -> do
+        Right a -> do -- KQueryArgs
           $(logDebugS) "handler.success" signature
-          return $ Right $ KResponse a queryId (Just $ ReflectedIP addr)
+#ifdef VERSION_bencoding
+          return $ Right $ KResponse a (queryId m) (Just $ ReflectedIP addr)
+#else
+          let cli = error "TODO TOX client node id"
+              messageid = error "TODO TOX message response id"
+              -- TODO: ReflectedIP addr ??
+          return $ Right $ Tox.Message messageid cli (queryId m) a
+#endif
 
     failbacks =
       [ E.Handler $ \ (e :: HandlerFailure) -> do
           $(logDebugS) "handler.failed" signature
-          return $ Left $ KError ProtocolError (prettyHF e) queryId
+#ifdef VERSION_bencoding
+          return $ Left $ KError ProtocolError (prettyHF e) (queryId m)
+#else
+          return $ Left $ decodeError "TODO TOX ProtocolError 2" (queryId m)
+#endif
+
 
         -- may happen if handler makes query and fail
       , E.Handler $ \ (e :: QueryFailure) -> do
-          return $ Left $ KError ServerError (prettyQF e) queryId
+#ifdef VERSION_bencoding
+          return $ Left $ KError ServerError (prettyQF e) (queryId m)
+#else
+          return $ Left $ decodeError "TODO TOX ServerError" (queryId m)
+#endif
 
         -- since handler thread exit after sendMessage we can safely
         -- suppress async exception here
       , E.Handler $ \ (e :: SomeException) -> do
-          return $ Left $ KError GenericError (BC.pack (show e)) queryId
+#ifdef VERSION_bencoding
+          return $ Left $ KError GenericError (BC.pack (show e)) (queryId m)
+#else
+          return $ Left $ decodeError "TODO TOX GenericError" (queryId m)
+#endif
       ]
 
 dispatchHandler :: MonadKRPC h m => KQuery -> SockAddr -> m KResult
-dispatchHandler q @ KQuery {..} addr = do
+dispatchHandler q addr = do
   Manager {..} <- getManager
-  case L.lookup queryMethod handlers of
-    Nothing -> return $ Left $ KError MethodUnknown queryMethod queryId
+  case L.lookup (queryMethod q) handlers of
+#ifdef VERSION_bencoding
+    Nothing -> return $ Left $ KError MethodUnknown (queryMethod q) (queryId q)
+#else
+    Nothing -> return $ Left $ decodeError "TODO TOX Error MethodUnknown" (queryId q)
+#endif
     Just h  -> runHandler h addr q
 
 {-----------------------------------------------------------------------
@@ -435,11 +508,12 @@ dispatchHandler q @ KQuery {..} addr = do
 -- peer B fork too many threads
 -- ... space leak
 --
-handleQuery :: MonadKRPC h m => BValue -> KQuery -> SockAddr -> m ()
+handleQuery :: MonadKRPC h m => KQueryArgs -> KQuery -> SockAddr -> m ()
 handleQuery raw q addr = void $ fork $ do
   myThreadId >>= liftIO . flip labelThread "KRPC.handleQuery"
   Manager {..} <- getManager
   res <- dispatchHandler q addr
+#ifdef VERSION_bencoding
   let resbe = either toBEncode toBEncode res
   $(logOther "q") $ T.unlines
     [ either (const "<unicode-fail>") id $ T.decodeUtf8' (BL.toStrict $ showBEncode raw)
@@ -447,21 +521,36 @@ handleQuery raw q addr = void $ fork $ do
     , either (const "<unicode-fail>") id $ T.decodeUtf8' (BL.toStrict $ showBEncode resbe)
     ]
   sendMessage sock addr resbe
+#else
+  -- Errors not sent for Tox.
+  either (const $ return ()) (sendMessage sock addr . S.encode) res
+#endif
 
-handleResponse :: MonadKRPC h m => BValue -> KResult -> SockAddr -> m ()
+handleResponse :: MonadKRPC h m => KQueryArgs -> KResult -> SockAddr -> m ()
 handleResponse raw result addr = do
   Manager {..} <- getManager
   liftIO $ do
+#ifdef VERSION_bencoding
     let resultId = either errorId respId  result
+#else
+    let resultId = either Tox.msgNonce Tox.msgNonce result
+#endif
     mcall <- unregisterQuery (resultId, addr) pendingCalls
     case mcall of
       Nothing   -> return ()
       Just ares -> putMVar ares (raw,result)
 
-handleMessage :: MonadKRPC h m => BValue -> KMessage -> SockAddr -> m ()
+#ifdef VERSION_bencoding
+handleMessage :: MonadKRPC h m => KQueryArgs -> KMessage -> SockAddr -> m ()
 handleMessage raw (Q q) = handleQuery    raw q
 handleMessage raw (R r) = handleResponse raw (Right r)
 handleMessage raw (E e) = handleResponse raw (Left  e)
+#else
+handleMessage :: MonadKRPC h m => KQueryArgs -> Tox.Message BC.ByteString -> SockAddr -> m ()
+handleMessage raw q | Tox.isQuery q    = handleQuery    raw q
+handleMessage raw r | Tox.isResponse r = handleResponse raw (Right r)
+handleMessage raw e | Tox.isError e    = handleResponse raw (Left  e)
+#endif
 
 listener :: MonadKRPC h m => m ()
 listener = do
@@ -469,9 +558,17 @@ listener = do
   fix $ \again -> do
     (bs, addr) <- liftIO $ do
       handle exceptions $ BS.recvFrom sock (optMaxMsgSize options)
+#ifdef VERSION_bencoding
     case BE.parse bs >>= \r -> (,) r <$> BE.decode bs of
+#else
+    case return bs >>= \r -> (,) r <$> decode bs of
+#endif
       -- TODO ignore unknown messages at all?
+#ifdef VERSION_bencoding
       Left  e       -> liftIO $ sendMessage sock addr $ unknownMessage e
+#else
+      Left  _       -> return () -- TODO TOX send unknownMessage error
+#endif
       Right (raw,m) -> handleMessage raw m addr
     again
   where
diff --git a/src/Network/KRPC/Message.hs b/src/Network/KRPC/Message.hs
index 6f4ae620..d48fa8ac 100644
--- a/src/Network/KRPC/Message.hs
+++ b/src/Network/KRPC/Message.hs
@@ -12,8 +12,10 @@
 --
 --   See <http://www.bittorrent.org/beps/bep_0005.html#krpc-protocol>
 --
+{-# LANGUAGE CPP                    #-}
 {-# LANGUAGE OverloadedStrings      #-}
 {-# LANGUAGE FlexibleContexts       #-}
+{-# LANGUAGE FlexibleInstances      #-}
 {-# LANGUAGE TypeSynonymInstances   #-}
 {-# LANGUAGE MultiParamTypeClasses  #-}
 {-# LANGUAGE FunctionalDependencies #-}
@@ -31,6 +33,11 @@ module Network.KRPC.Message
 
          -- * Query
        , KQuery(..)
+#ifndef VERSION_bencoding
+       , queryArgs
+       , queryMethod
+       , queryId
+#endif
        , MethodName
 
          -- * Response
@@ -39,12 +46,18 @@ module Network.KRPC.Message
 
          -- * Message
        , KMessage (..)
+       , KQueryArgs
+
        ) where
 
 import Control.Applicative
 import Control.Arrow
 import Control.Exception.Lifted as Lifted
+#ifdef VERSION_bencoding
 import Data.BEncode as BE
+#else
+import qualified Data.Tox as Tox
+#endif
 import Data.ByteString as B
 import Data.ByteString.Char8 as BC
 import qualified Data.Serialize as S
@@ -53,15 +66,23 @@ import Data.Typeable
 import Network.Socket (SockAddr (..),PortNumber,HostAddress)
 
 
+#ifdef VERSION_bencoding
 -- | This transaction ID is generated by the querying node and is
 -- echoed in the response, so responses may be correlated with
 -- multiple queries to the same node. The transaction ID should be
 -- encoded as a short string of binary numbers, typically 2 characters
 -- are enough as they cover 2^16 outstanding queries.
 type TransactionId = ByteString
+#else
+type TransactionId = Tox.Nonce24 -- msgNonce
+#endif
 
 unknownTransaction :: TransactionId
+#ifdef VERSION_bencoding
 unknownTransaction = ""
+#else
+unknownTransaction = 0
+#endif
 
 {-----------------------------------------------------------------------
 -- Error messages
@@ -98,13 +119,16 @@ instance Enum ErrorCode where
   toEnum _   = GenericError
   {-# INLINE toEnum #-}
 
+#ifdef VERSION_bencoding
 instance BEncode ErrorCode where
   toBEncode = toBEncode . fromEnum
   {-# INLINE toBEncode #-}
 
   fromBEncode b = toEnum <$> fromBEncode b
   {-# INLINE fromBEncode #-}
+#endif
 
+#ifdef VERSION_bencoding
 -- | Errors are sent when a query cannot be fulfilled. Error message
 --   can be send only from server to client but not in the opposite
 --   direction.
@@ -113,7 +137,10 @@ data KError = KError
   { errorCode    :: !ErrorCode     -- ^ the type of error;
   , errorMessage :: !ByteString    -- ^ human-readable text message;
   , errorId      :: !TransactionId -- ^ match to the corresponding 'queryId'.
-  } deriving (Show, Read, Eq, Ord, Typeable)
+  } deriving ( Show, Eq, Ord, Typeable, Read )
+#else
+type KError = Tox.Message ByteString -- TODO TOX unused
+#endif
 
 -- | Errors, or KRPC message dictionaries with a \"y\" value of \"e\",
 --   contain one additional key \"e\". The value of \"e\" is a
@@ -129,6 +156,7 @@ data KError = KError
 --
 --   > d1:eli201e23:A Generic Error Ocurrede1:t2:aa1:y1:ee
 --
+#ifdef VERSION_bencoding
 instance BEncode KError where
   toBEncode KError {..} = toDict $
        "e" .=! (errorCode, errorMessage)
@@ -142,33 +170,49 @@ instance BEncode KError where
     (code, msg) <- field (req "e")
     KError code msg <$>! "t"
   {-# INLINE fromBEncode #-}
+#endif
 
 instance Exception KError
 
 -- | Received 'queryArgs' or 'respVals' can not be decoded.
 decodeError :: String -> TransactionId -> KError
+#ifdef VERSION_bencoding
 decodeError msg = KError ProtocolError (BC.pack msg)
+#else
+decodeError msg = error "TODO TOX Error packet"
+#endif
 
 -- | A remote node has send some 'KMessage' this node is unable to
 -- decode.
 unknownMessage :: String -> KError
+#ifdef VERSION_bencoding
 unknownMessage msg = KError ProtocolError (BC.pack msg) unknownTransaction
+#else
+unknownMessage msg = error "TODO TOX Protocol error"
+#endif
 
 {-----------------------------------------------------------------------
 -- Query messages
 -----------------------------------------------------------------------}
 
+#ifdef VERSION_bencoding
 type MethodName = ByteString
+type KQueryArgs = BValue
+#else
+type MethodName = Tox.MessageType -- msgType
+type KQueryArgs = ByteString      -- msgPayload
+#endif
 
+#ifdef VERSION_bencoding
 -- | Query used to signal that caller want to make procedure call to
 -- callee and pass arguments in. Therefore query may be only sent from
 -- client to server but not in the opposite direction.
 --
 data KQuery = KQuery
-  { queryArgs   :: !BValue         -- ^ values to be passed to method;
+  { queryArgs   :: !KQueryArgs     -- ^ values to be passed to method;
   , queryMethod :: !MethodName     -- ^ method to call;
   , queryId     :: !TransactionId  -- ^ one-time query token.
-  } deriving (Show, Read, Eq, Ord, Typeable)
+  } deriving ( Show, Eq, Ord, Typeable, Read )
 
 -- | Queries, or KRPC message dictionaries with a \"y\" value of
 -- \"q\", contain two additional keys; \"q\" and \"a\". Key \"q\" has
@@ -193,13 +237,19 @@ instance BEncode KQuery where
     KQuery <$>! "a" <*>! "q" <*>! "t"
   {-# INLINE fromBEncode #-}
 
-newtype ReflectedIP = ReflectedIP SockAddr
-  deriving (Eq, Ord, Show)
-
 instance BEncode ReflectedIP where
   toBEncode (ReflectedIP addr) = BString (encodeAddr addr)
   fromBEncode (BString bs) = ReflectedIP <$> decodeAddr bs
   fromBEncode _            = Left "ReflectedIP should be a bencoded string"
+#else
+type KQuery = Tox.Message KQueryArgs
+queryArgs   = Tox.msgPayload
+queryMethod = Tox.msgType
+queryId     = Tox.msgNonce
+#endif
+
+newtype ReflectedIP = ReflectedIP SockAddr
+  deriving (Eq, Ord, Show)
 
 port16 :: Word16 -> PortNumber
 port16 = fromIntegral
@@ -237,8 +287,9 @@ encodeAddr _ = B.empty
 --
 --   * KResponse can be only sent from server to client.
 --
+#ifdef VERSION_bencoding
 data KResponse = KResponse
-  { respVals :: BValue         -- ^ 'BDict' containing return values;
+  { respVals :: KQueryArgs     -- ^ 'BDict' containing return values;
   , respId   :: TransactionId  -- ^ match to the corresponding 'queryId'.
   , respIP   :: Maybe ReflectedIP
   } deriving (Show, Eq, Ord, Typeable)
@@ -265,11 +316,18 @@ instance BEncode KResponse where
     addr <- optional (field (req "ip"))
     (\r t -> KResponse r t addr) <$>! "r" <*>! "t"
   {-# INLINE fromBEncode #-}
+#else
+type KResponse = Tox.Message KQueryArgs
+respVals       = Tox.msgPayload
+respId         = Tox.msgNonce
+respIP         = Nothing :: Maybe ReflectedIP
+#endif
 
 {-----------------------------------------------------------------------
 -- Summed messages
 -----------------------------------------------------------------------}
 
+#ifdef VERSION_bencoding
 -- | Generic KRPC message.
 data KMessage
   = Q KQuery
@@ -287,3 +345,6 @@ instance BEncode KMessage where
     <|> R <$> fromBEncode b
     <|> E <$> fromBEncode b
     <|> decodingError "KMessage: unknown message or message tag"
+#else
+type KMessage = Tox.Message
+#endif
diff --git a/src/Network/KRPC/Method.hs b/src/Network/KRPC/Method.hs
index 916b38a8..2a791924 100644
--- a/src/Network/KRPC/Method.hs
+++ b/src/Network/KRPC/Method.hs
@@ -7,6 +7,7 @@
 --
 --   Normally, you don't need to import this module.
 --
+{-# LANGUAGE CPP                        #-}
 {-# LANGUAGE RankNTypes                 #-}
 {-# LANGUAGE MultiParamTypeClasses      #-}
 {-# LANGUAGE GeneralizedNewtypeDeriving #-}
@@ -17,7 +18,11 @@ module Network.KRPC.Method
        , KRPC (..)
        ) where
 
+#ifdef VERSION_bencoding
 import Data.BEncode (BEncode)
+#else
+import Data.Serialize
+#endif
 import Data.ByteString.Char8 as BC
 import Data.Char
 import Data.Monoid
@@ -38,7 +43,12 @@ import Network.KRPC.Message
 --     * result: Type of return value of the method.
 --
 newtype Method param result = Method { methodName :: MethodName }
-  deriving (Eq, Ord, IsString, BEncode)
+  deriving ( Eq, Ord
+#ifdef VERSION_bencoding
+           , IsString
+           , BEncode
+#endif
+           )
 
 -- | Example:
 --
@@ -49,7 +59,11 @@ instance (Typeable a, Typeable b) => Show (Method a b) where
 
 showsMethod :: forall a b. ( Typeable a , Typeable b ) => Method a b -> ShowS
 showsMethod (Method name) =
+#ifdef VERSION_bencoding
     showString (BC.unpack name) <>
+#else
+    shows (show name) <>
+#endif
     showString " :: " <>
     shows paramsTy <>
     showString " -> " <>
@@ -72,7 +86,13 @@ showsMethod (Method name) =
 --     method = \"ping\"
 --   @
 --
-class (Typeable req, BEncode req, Typeable resp, BEncode resp)
+class ( Typeable req, Typeable resp
+#ifdef VERSION_bencoding
+      , BEncode req, BEncode resp
+#else
+      , Serialize req, Serialize resp
+#endif
+      )
     => KRPC req resp where
 
   -- | Method name. Default implementation uses lowercased @req@
@@ -80,8 +100,10 @@ class (Typeable req, BEncode req, Typeable resp, BEncode resp)
   --
   method :: Method req resp
 
+#ifdef VERSION_bencoding
   -- TODO add underscores
   default method :: Typeable req => Method req resp
   method = Method $ fromString $ L.map toLower $ show $ typeOf hole
     where
       hole = error "krpc.method: impossible" :: req
+#endif