Renamed Assym -> Asymm (short for asymmetric).

7 files changed, 126 insertions, 126 deletions

diff --git a/src/Crypto/Tox.hs b/src/Crypto/Tox.hs
index 645ca53e..ed8ec59e 100644
--- a/src/Crypto/Tox.hs
+++ b/src/Crypto/Tox.hs
@@ -20,11 +20,11 @@ module Crypto.Tox
     , Encrypted
     , Encrypted8(..)
     , type (∘)(..)
-    , Assym(..)
-    , getAssym
-    , getAliasedAssym
-    , putAssym
-    , putAliasedAssym
+    , Asymm(..)
+    , getAsymm
+    , getAliasedAsymm
+    , putAsymm
+    , putAliasedAsymm
     , Plain
     , encodePlain
     , decodePlain
@@ -326,34 +326,34 @@ zeros24 = BA.take 24 zs where Nonce32 zs = zeros32
 -- | `32`   | sender's DHT public key   |
 -- | `24`   | nonce                     |
 -- | `?`    | encrypted message         |
-data Assym a = Assym
+data Asymm a = Asymm
     { senderKey :: PublicKey
-    , assymNonce :: Nonce24
-    , assymData :: a
+    , asymmNonce :: Nonce24
+    , asymmData :: a
     }
  deriving (Functor,Foldable,Traversable, Show)
 
-instance Sized a => Sized (Assym a) where
+instance Sized a => Sized (Asymm a) where
     size = case size of
         ConstSize a -> ConstSize $ a + 24 + 32
-        VarSize f   -> VarSize $ \Assym { assymData = x } -> f x + 24 + 32
+        VarSize f   -> VarSize $ \Asymm { asymmData = x } -> f x + 24 + 32
 
 -- | Field order: senderKey, then nonce This is the format used by
 -- Ping/Pong/GetNodes/SendNodes.
 --
--- See 'getAliasedAssym' if the nonce precedes the key.
-getAssym :: Serialize a => Get (Assym a)
-getAssym = Assym <$> getPublicKey <*> get <*> get
+-- See 'getAliasedAsymm' if the nonce precedes the key.
+getAsymm :: Serialize a => Get (Asymm a)
+getAsymm = Asymm <$> getPublicKey <*> get <*> get
 
-putAssym :: Serialize a => Assym a -> Put
-putAssym (Assym key nonce dta) = putPublicKey key >> put nonce >> put dta
+putAsymm :: Serialize a => Asymm a -> Put
+putAsymm (Asymm key nonce dta) = putPublicKey key >> put nonce >> put dta
 
 -- | Field order: nonce, and then senderKey.
-getAliasedAssym :: Serialize a => Get (Assym a)
-getAliasedAssym = flip Assym <$> get <*> getPublicKey <*> get
+getAliasedAsymm :: Serialize a => Get (Asymm a)
+getAliasedAsymm = flip Asymm <$> get <*> getPublicKey <*> get
 
-putAliasedAssym :: Serialize a => Assym a -> Put
-putAliasedAssym (Assym key nonce dta) = put nonce >> putPublicKey key >> put dta
+putAliasedAsymm :: Serialize a => Asymm a -> Put
+putAliasedAsymm (Asymm key nonce dta) = put nonce >> putPublicKey key >> put dta
 
 newtype SymmetricKey = SymmetricKey ByteString
 
diff --git a/src/Network/Tox.hs b/src/Network/Tox.hs
index 908691df..987f742c 100644
--- a/src/Network/Tox.hs
+++ b/src/Network/Tox.hs
@@ -208,7 +208,7 @@ newClient drg net classify selfAddr handlers modifytbl modifynet = do
 data Tox = Tox
     { toxDHT :: DHT.Client
     , toxOnion :: Onion.Client RouteId
-    , toxToRoute :: Transport String Onion.Rendezvous (Assym (Encrypted Onion.DataToRoute))
+    , toxToRoute :: Transport String Onion.Rendezvous (Asymm (Encrypted Onion.DataToRoute))
     , toxCrypto :: Transport String SockAddr NetCrypto
     , toxCryptoKeys :: TransportCrypto
     , toxRouting :: DHT.Routing
diff --git a/src/Network/Tox/DHT/Handlers.hs b/src/Network/Tox/DHT/Handlers.hs
index a3f13ac7..4f891316 100644
--- a/src/Network/Tox/DHT/Handlers.hs
+++ b/src/Network/Tox/DHT/Handlers.hs
@@ -188,29 +188,29 @@ type Message = DHTMessage ((,) Nonce8)
 type Client = QR.Client String PacketKind TransactionId NodeInfo Message
 
 
-wrapAssym :: TransactionId -> NodeInfo -> NodeInfo -> (Nonce8 -> dta) -> Assym dta
-wrapAssym (TransactionId n8 n24) src dst dta = Assym
+wrapAsymm :: TransactionId -> NodeInfo -> NodeInfo -> (Nonce8 -> dta) -> Asymm dta
+wrapAsymm (TransactionId n8 n24) src dst dta = Asymm
     { senderKey = id2key $ nodeId src
-    , assymNonce = n24
-    , assymData = dta n8
+    , asymmNonce = n24
+    , asymmData = dta n8
     }
 
 serializer :: PacketKind
-                -> (Assym (Nonce8,ping) -> Message)
-                -> (Message -> Maybe (Assym (Nonce8,pong)))
+                -> (Asymm (Nonce8,ping) -> Message)
+                -> (Message -> Maybe (Asymm (Nonce8,pong)))
                 -> MethodSerializer TransactionId NodeInfo Message PacketKind ping (Maybe pong)
 serializer pktkind mkping mkpong = MethodSerializer
         { methodTimeout  = \tid addr -> return (addr, 5000000)
         , method         = pktkind
         -- wrapQuery :: tid -> addr -> addr -> qry -> x
-        , wrapQuery      = \tid src dst ping -> mkping $ wrapAssym tid src dst (, ping)
+        , wrapQuery      = \tid src dst ping -> mkping $ wrapAsymm tid src dst (, ping)
         -- unwrapResponse :: x -> b
-        , unwrapResponse = fmap (snd . assymData) . mkpong
+        , unwrapResponse = fmap (snd . asymmData) . mkpong
         }
 
 
-unpong :: Message -> Maybe (Assym (Nonce8,Pong))
-unpong (DHTPong assym) = Just assym
+unpong :: Message -> Maybe (Asymm (Nonce8,Pong))
+unpong (DHTPong asymm) = Just asymm
 unpong _               = Nothing
 
 showHex :: BA.ByteArrayAccess ba => ba -> String
@@ -223,8 +223,8 @@ ping client addr = do
     hPutStrLn stderr $ show addr ++ " -pong-> " ++ show reply
     maybe (return False) (\Pong -> return True) $ join reply
 
-unsendNodes :: Message -> Maybe (Assym (Nonce8,SendNodes))
-unsendNodes (DHTSendNodes assym) = Just assym
+unsendNodes :: Message -> Maybe (Asymm (Nonce8,SendNodes))
+unsendNodes (DHTSendNodes asymm) = Just asymm
 unsendNodes _                    = Nothing
 
 unwrapNodes :: SendNodes -> ( [NodeInfo], [NodeInfo], () )
@@ -285,18 +285,18 @@ transitionCommittee committee _ = return $ return ()
 type Handler = MethodHandler String TransactionId NodeInfo Message
 
 isPing :: (f Ping -> Ping) ->  DHTMessage f -> Either String Ping
-isPing unpack (DHTPing a) = Right $ unpack $ assymData a
+isPing unpack (DHTPing a) = Right $ unpack $ asymmData a
 isPing _      _           = Left "Bad ping"
 
 mkPong :: TransactionId -> NodeInfo -> NodeInfo -> Pong -> DHTMessage ((,) Nonce8)
-mkPong tid src dst pong = DHTPong $ wrapAssym tid src dst (, pong)
+mkPong tid src dst pong = DHTPong $ wrapAsymm tid src dst (, pong)
 
 isGetNodes :: (f GetNodes -> GetNodes) ->  DHTMessage f -> Either String GetNodes
-isGetNodes unpack (DHTGetNodes a) = Right $ unpack $ assymData a
+isGetNodes unpack (DHTGetNodes a) = Right $ unpack $ asymmData a
 isGetNodes _      _               = Left "Bad GetNodes"
 
 mkSendNodes :: TransactionId -> NodeInfo -> NodeInfo -> SendNodes -> DHTMessage ((,) Nonce8)
-mkSendNodes tid src dst sendnodes = DHTSendNodes $ wrapAssym tid src dst (, sendnodes)
+mkSendNodes tid src dst sendnodes = DHTSendNodes $ wrapAsymm tid src dst (, sendnodes)
 
 handlers :: Routing -> PacketKind -> Maybe Handler
 handlers routing PingType     = Just $ MethodHandler (isPing snd) mkPong pingH
diff --git a/src/Network/Tox/DHT/Transport.hs b/src/Network/Tox/DHT/Transport.hs
index 16af0e3f..5bd9caa1 100644
--- a/src/Network/Tox/DHT/Transport.hs
+++ b/src/Network/Tox/DHT/Transport.hs
@@ -50,30 +50,30 @@ type HandleHi a = Maybe (Either String (DHTMessage Encrypted8, NodeInfo)) -> IO
 
 
 data DHTMessage (f :: * -> *)
-    = DHTPing (Assym (f Ping))
-    | DHTPong (Assym (f Pong))
-    | DHTGetNodes (Assym (f GetNodes))
-    | DHTSendNodes (Assym (f SendNodes))
-    | DHTCookieRequest (Assym (f CookieRequest))
+    = DHTPing (Asymm (f Ping))
+    | DHTPong (Asymm (f Pong))
+    | DHTGetNodes (Asymm (f GetNodes))
+    | DHTSendNodes (Asymm (f SendNodes))
+    | DHTCookieRequest (Asymm (f CookieRequest))
     | DHTCookie Nonce24 (f Cookie)
-    | DHTDHTRequest PublicKey (Assym (f DHTRequest))
+    | DHTDHTRequest PublicKey (Asymm (f DHTRequest))
 
 deriving instance ( Show (f Cookie)
-                  , Show (Assym (f Ping))
-                  , Show (Assym (f Pong))
-                  , Show (Assym (f GetNodes))
-                  , Show (Assym (f SendNodes))
-                  , Show (Assym (f CookieRequest))
-                  , Show (Assym (f DHTRequest))
+                  , Show (Asymm (f Ping))
+                  , Show (Asymm (f Pong))
+                  , Show (Asymm (f GetNodes))
+                  , Show (Asymm (f SendNodes))
+                  , Show (Asymm (f CookieRequest))
+                  , Show (Asymm (f DHTRequest))
                   ) => Show (DHTMessage f)
 
 mapMessage :: forall f b. (forall a. Nonce24 -> f a -> b) -> DHTMessage f -> b
-mapMessage f (DHTPing          a) = f (assymNonce a) (assymData a)
-mapMessage f (DHTPong          a) = f (assymNonce a) (assymData a)
-mapMessage f (DHTGetNodes      a) = f (assymNonce a) (assymData a)
-mapMessage f (DHTSendNodes     a) = f (assymNonce a) (assymData a)
-mapMessage f (DHTCookieRequest a) = f (assymNonce a) (assymData a)
-mapMessage f (DHTDHTRequest  _ a) = f (assymNonce a) (assymData a)
+mapMessage f (DHTPing          a) = f (asymmNonce a) (asymmData a)
+mapMessage f (DHTPong          a) = f (asymmNonce a) (asymmData a)
+mapMessage f (DHTGetNodes      a) = f (asymmNonce a) (asymmData a)
+mapMessage f (DHTSendNodes     a) = f (asymmNonce a) (asymmData a)
+mapMessage f (DHTCookieRequest a) = f (asymmNonce a) (asymmData a)
+mapMessage f (DHTDHTRequest  _ a) = f (asymmNonce a) (asymmData a)
 mapMessage f (DHTCookie nonce fcookie) = f nonce fcookie
 
 
@@ -99,13 +99,13 @@ encodeDHTAddr :: (DHTMessage Encrypted8,NodeInfo) -> (ByteString, SockAddr)
 encodeDHTAddr (msg,ni) = (runPut $ putMessage msg, nodeAddr ni)
 
 dhtMessageType :: DHTMessage Encrypted8 -> ( Word8, Put )
-dhtMessageType (DHTPing           a) = (0x00, putAssym a)
-dhtMessageType (DHTPong           a) = (0x01, putAssym a)
-dhtMessageType (DHTGetNodes       a) = (0x02, putAssym a)
-dhtMessageType (DHTSendNodes      a) = (0x04, putAssym a)
-dhtMessageType (DHTCookieRequest  a) = (0x18, putAssym a)
+dhtMessageType (DHTPing           a) = (0x00, putAsymm a)
+dhtMessageType (DHTPong           a) = (0x01, putAsymm a)
+dhtMessageType (DHTGetNodes       a) = (0x02, putAsymm a)
+dhtMessageType (DHTSendNodes      a) = (0x04, putAsymm a)
+dhtMessageType (DHTCookieRequest  a) = (0x18, putAsymm a)
 dhtMessageType (DHTCookie       n x) = (0x19, put n >> put x)
-dhtMessageType (DHTDHTRequest   k a) = (0x20, putPublicKey k >> putAssym a)
+dhtMessageType (DHTDHTRequest   k a) = (0x20, putPublicKey k >> putAsymm a)
 
 putMessage :: DHTMessage Encrypted8 -> Put
 putMessage msg = case dhtMessageType msg of (typ,p) -> put typ >> p
@@ -113,8 +113,8 @@ putMessage msg = case dhtMessageType msg of (typ,p) -> put typ >> p
 getCookie :: Get (Nonce24, Encrypted8 Cookie)
 getCookie = get
 
-getDHTReqest :: Get (PublicKey, Assym (Encrypted8 DHTRequest))
-getDHTReqest = (,) <$> getPublicKey <*> getAssym
+getDHTReqest :: Get (PublicKey, Asymm (Encrypted8 DHTRequest))
+getDHTReqest = (,) <$> getPublicKey <*> getAsymm
 
 -- ## DHT Request packets
 --
@@ -125,19 +125,19 @@ getDHTReqest = (,) <$> getPublicKey <*> getAssym
 --   ...      ...
 
 
-getDHT :: Sized a => Get (Assym (Encrypted8 a))
-getDHT = getAssym
+getDHT :: Sized a => Get (Asymm (Encrypted8 a))
+getDHT = getAsymm
 
 
 -- Throws an error if called with a non-internet socket.
 direct :: Sized a => ByteString
                   -> SockAddr
-                  -> (Assym (Encrypted8 a) -> DHTMessage Encrypted8)
+                  -> (Asymm (Encrypted8 a) -> DHTMessage Encrypted8)
                   -> Either String (DHTMessage Encrypted8, NodeInfo)
 direct bs saddr f = fanGet bs getDHT f (asymNodeInfo saddr)
 
 -- Throws an error if called with a non-internet socket.
-asymNodeInfo :: SockAddr -> Assym a -> NodeInfo
+asymNodeInfo :: SockAddr -> Asymm a -> NodeInfo
 asymNodeInfo saddr asym = either (error . mappend "asymNodeInfo: ") id $ nodeInfo (key2id $ senderKey asym) saddr
 
 
@@ -351,11 +351,11 @@ encrypt crypto msg ni = ( transcode (encryptMessage crypto (id2key $ nodeId ni))
 encryptMessage :: Serialize a =>
                   TransportCrypto ->
                   PublicKey ->
-                  Nonce24 -> Either (Nonce8,a) (Assym (Nonce8,a)) -> Encrypted8 a
-encryptMessage crypto destKey n (Right assym) = E8 $ ToxCrypto.encrypt secret plain
+                  Nonce24 -> Either (Nonce8,a) (Asymm (Nonce8,a)) -> Encrypted8 a
+encryptMessage crypto destKey n (Right asymm) = E8 $ ToxCrypto.encrypt secret plain
  where
     secret = computeSharedSecret (transportSecret crypto) destKey n
-    plain  = encodePlain $ swap $ assymData assym
+    plain  = encodePlain $ swap $ asymmData asymm
 encryptMessage crypto destKey n (Left plain) = _todo -- need cached public key.
 
 decrypt :: TransportCrypto -> DHTMessage Encrypted8 -> NodeInfo -> Either String (DHTMessage ((,) Nonce8), NodeInfo)
@@ -364,12 +364,12 @@ decrypt crypto msg ni = (, ni) <$> (sequenceMessage $ transcode (decryptMessage
 decryptMessage :: Serialize x =>
                   TransportCrypto
                   -> Nonce24
-                  -> Either (Encrypted8 x) (Assym (Encrypted8 x))
+                  -> Either (Encrypted8 x) (Asymm (Encrypted8 x))
                   -> (Either String ∘ ((,) Nonce8)) x
-decryptMessage crypto n (Right assymE) = plain8 $ ToxCrypto.decrypt secret e
+decryptMessage crypto n (Right asymmE) = plain8 $ ToxCrypto.decrypt secret e
  where
-    secret = computeSharedSecret (transportSecret crypto) (senderKey assymE) n
-    E8 e   = assymData assymE
+    secret = computeSharedSecret (transportSecret crypto) (senderKey asymmE) n
+    E8 e   = asymmData asymmE
     plain8 = Composed . fmap swap . (>>= decodePlain)
 decryptMessage crypto n (Left (E8 e)) = _todo -- need cached public key
 
@@ -382,11 +382,11 @@ sequenceMessage (DHTCookieRequest asym)     = fmap DHTCookieRequest $ sequenceA
 sequenceMessage (DHTCookie n dta)           = fmap (DHTCookie n)    $ uncomposed dta
 sequenceMessage (DHTDHTRequest pubkey asym) = fmap (DHTDHTRequest pubkey) $ sequenceA $ fmap uncomposed asym
 
-transcode :: forall f g. (forall a. Serialize a => Nonce24 -> Either (f a) (Assym (f a)) -> g a) -> DHTMessage f -> DHTMessage g
-transcode f (DHTPing asym)              = DHTPing              $ asym { assymData = f (assymNonce asym) (Right asym) }
-transcode f (DHTPong asym)              = DHTPong              $ asym { assymData = f (assymNonce asym) (Right asym) }
-transcode f (DHTGetNodes asym)          = DHTGetNodes          $ asym { assymData = f (assymNonce asym) (Right asym) }
-transcode f (DHTSendNodes asym)         = DHTSendNodes         $ asym { assymData = f (assymNonce asym) (Right asym) }
-transcode f (DHTCookieRequest asym)     = DHTCookieRequest     $ asym { assymData = f (assymNonce asym) (Right asym) }
+transcode :: forall f g. (forall a. Serialize a => Nonce24 -> Either (f a) (Asymm (f a)) -> g a) -> DHTMessage f -> DHTMessage g
+transcode f (DHTPing asym)              = DHTPing              $ asym { asymmData = f (asymmNonce asym) (Right asym) }
+transcode f (DHTPong asym)              = DHTPong              $ asym { asymmData = f (asymmNonce asym) (Right asym) }
+transcode f (DHTGetNodes asym)          = DHTGetNodes          $ asym { asymmData = f (asymmNonce asym) (Right asym) }
+transcode f (DHTSendNodes asym)         = DHTSendNodes         $ asym { asymmData = f (asymmNonce asym) (Right asym) }
+transcode f (DHTCookieRequest asym)     = DHTCookieRequest     $ asym { asymmData = f (asymmNonce asym) (Right asym) }
 transcode f (DHTCookie n dta)           = DHTCookie n          $ f n  $ Left dta
-transcode f (DHTDHTRequest pubkey asym) = DHTDHTRequest pubkey $ asym { assymData = f (assymNonce asym) (Right asym) }
+transcode f (DHTDHTRequest pubkey asym) = DHTDHTRequest pubkey $ asym { asymmData = f (asymmNonce asym) (Right asym) }
diff --git a/src/Network/Tox/Onion/Handlers.hs b/src/Network/Tox/Onion/Handlers.hs
index 103c216b..23673273 100644
--- a/src/Network/Tox/Onion/Handlers.hs
+++ b/src/Network/Tox/Onion/Handlers.hs
@@ -46,8 +46,8 @@ classify :: Message -> MessageClass String PacketKind TransactionId
 classify msg = go msg
  where
     go (OnionAnnounce         announce)    = IsQuery AnnounceType
-                                                $ TransactionId (snd $ runIdentity $ assymData announce)
-                                                                (assymNonce announce)
+                                                $ TransactionId (snd $ runIdentity $ asymmData announce)
+                                                                (asymmNonce announce)
     go (OnionAnnounceResponse n8 n24 resp) = IsResponse (TransactionId n8 n24)
     go (OnionToRoute          {})          = IsQuery DataRequestType (TransactionId (Nonce8 0) (Nonce24 zeros24))
     go (OnionToRouteResponse  {})          = IsResponse              (TransactionId (Nonce8 0) (Nonce24 zeros24))
@@ -116,7 +116,7 @@ dataToRouteH ::
           -> addr
           -> OnionMessage f
           -> IO ()
-dataToRouteH keydb udp _ (OnionToRoute pub assym) = do
+dataToRouteH keydb udp _ (OnionToRoute pub asymm) = do
     let k = key2id pub
     mb <- atomically $ do
         ks <- readTVar keydb
@@ -125,7 +125,7 @@ dataToRouteH keydb udp _ (OnionToRoute pub assym) = do
             return rpath
     forM_ mb $ \rpath -> do
         -- forward
-        sendMessage udp (toOnionDestination rpath) $ OnionToRouteResponse assym
+        sendMessage udp (toOnionDestination rpath) $ OnionToRouteResponse asymm
         hPutStrLn stderr $ "Forwarding data-to-route -->"++show k
 
 type NodeDistance = NodeId
@@ -150,7 +150,7 @@ insertKey tm pub toxpath d keydb = AnnouncedKeys
     }
 
 areq :: Message -> Either String AnnounceRequest
-areq (OnionAnnounce assym) = Right $ fst $ runIdentity $ assymData assym
+areq (OnionAnnounce asymm) = Right $ fst $ runIdentity $ asymmData asymm
 areq _                     = Left "Unexpected non-announce OnionMessage"
 
 handlers :: Transport err (OnionDestination r) Message
@@ -189,13 +189,13 @@ announceSerializer getTimeout = MethodSerializer
     , method = AnnounceType
     , wrapQuery = \(TransactionId n8 n24) src dst req ->
         -- :: tid -> addr -> addr -> a -> OnionMessage Identity
-        OnionAnnounce $ Assym
+        OnionAnnounce $ Asymm
             { -- The public key is our real long term public key if we want to
               -- announce ourselves, a temporary one if we are searching for
               -- friends.
               senderKey = onionKey src
-            , assymNonce = n24
-            , assymData = Identity (req, n8)
+            , asymmNonce = n24
+            , asymmData = Identity (req, n8)
             }
     , unwrapResponse = \case -- :: OnionMessage Identity -> b
         OnionAnnounceResponse _ _ resp -> Just $ runIdentity resp
diff --git a/src/Network/Tox/Onion/Transport.hs b/src/Network/Tox/Onion/Transport.hs
index 82f2c8a7..203d7dc7 100644
--- a/src/Network/Tox/Onion/Transport.hs
+++ b/src/Network/Tox/Onion/Transport.hs
@@ -78,17 +78,17 @@ type HandleLo a = Maybe (Either String (ByteString, SockAddr)) -> IO a
 type UDPTransport = Transport String SockAddr ByteString
 
 
-getOnionAssym :: Get (Assym (Encrypted DataToRoute))
-getOnionAssym = getAliasedAssym
+getOnionAsymm :: Get (Asymm (Encrypted DataToRoute))
+getOnionAsymm = getAliasedAsymm
 
-putOnionAssym :: Serialize a => Word8 -> Put -> Assym a -> Put
-putOnionAssym typ p a = put typ >> p >> putAliasedAssym a
+putOnionAsymm :: Serialize a => Word8 -> Put -> Asymm a -> Put
+putOnionAsymm typ p a = put typ >> p >> putAliasedAsymm a
 
 data OnionMessage (f :: * -> *)
-    = OnionAnnounce (Assym (f (AnnounceRequest,Nonce8)))
+    = OnionAnnounce (Asymm (f (AnnounceRequest,Nonce8)))
     | OnionAnnounceResponse Nonce8 Nonce24 (f AnnounceResponse)
-    | OnionToRoute PublicKey (Assym (Encrypted DataToRoute)) -- destination key, aliased Assym
-    | OnionToRouteResponse (Assym (Encrypted DataToRoute))
+    | OnionToRoute PublicKey (Asymm (Encrypted DataToRoute)) -- destination key, aliased Asymm
+    | OnionToRouteResponse (Asymm (Encrypted DataToRoute))
 
 deriving instance ( Show (f (AnnounceRequest, Nonce8))
                   , Show (f AnnounceResponse)
@@ -96,10 +96,10 @@ deriving instance ( Show (f (AnnounceRequest, Nonce8))
                   ) => Show (OnionMessage f)
 
 msgNonce :: OnionMessage f -> Nonce24
-msgNonce (OnionAnnounce a)               = assymNonce a
+msgNonce (OnionAnnounce a)               = asymmNonce a
 msgNonce (OnionAnnounceResponse _ n24 _) = n24
-msgNonce (OnionToRoute _ a)              = assymNonce a
-msgNonce (OnionToRouteResponse a)        = assymNonce a
+msgNonce (OnionToRoute _ a)              = asymmNonce a
+msgNonce (OnionToRouteResponse a)        = asymmNonce a
 
 data AliasSelector = SearchingAlias | AnnouncingAlias SecretKey PublicKey
     deriving (Eq,Show)
@@ -138,18 +138,18 @@ instance Serialize (OnionMessage Encrypted) where
     get = do
         typ <- get
         case typ :: Word8 of
-            0x83 -> OnionAnnounce <$> getAliasedAssym
-            0x85 -> OnionToRoute <$> getPublicKey <*> getAliasedAssym
+            0x83 -> OnionAnnounce <$> getAliasedAsymm
+            0x85 -> OnionToRoute <$> getPublicKey <*> getAliasedAsymm
             t    -> fail ("Unknown onion payload: " ++ show t)
                     `fromMaybe` getOnionReply t
-    put (OnionAnnounce a)                = putWord8 0x83 >> putAliasedAssym a
-    put (OnionToRoute k a)               = putWord8 0x85 >> putPublicKey k >> putAliasedAssym a
+    put (OnionAnnounce a)                = putWord8 0x83 >> putAliasedAsymm a
+    put (OnionToRoute k a)               = putWord8 0x85 >> putPublicKey k >> putAliasedAsymm a
     put (OnionAnnounceResponse n8 n24 x) = putWord8 0x84 >> put n8 >> put n24 >> put x
-    put (OnionToRouteResponse a)         = putWord8 0x86 >> putAliasedAssym a
+    put (OnionToRouteResponse a)         = putWord8 0x86 >> putAliasedAsymm a
 
-onionToOwner :: Assym a -> ReturnPath N3 -> SockAddr -> Either String (OnionDestination r)
-onionToOwner assym ret3 saddr = do
-    ni <- nodeInfo (key2id $ senderKey assym) saddr
+onionToOwner :: Asymm a -> ReturnPath N3 -> SockAddr -> Either String (OnionDestination r)
+onionToOwner asymm ret3 saddr = do
+    ni <- nodeInfo (key2id $ senderKey asymm) saddr
     return $ OnionToOwner ni ret3
 -- data CookieAddress = WithoutCookie NodeInfo | CookieAddress Cookie SockAddr
 
@@ -157,11 +157,11 @@ onionToOwner assym ret3 saddr = do
 onion :: Sized msg =>
                ByteString
                -> SockAddr
-               -> Get (Assym (Encrypted msg) -> t)
+               -> Get (Asymm (Encrypted msg) -> t)
                -> Either String (t, OnionDestination r)
-onion bs saddr getf = do (f,(assym,ret3)) <- runGet ((,) <$> getf <*> getOnionRequest) bs
-                         oaddr <- onionToOwner assym ret3 saddr
-                         return (f assym, oaddr)
+onion bs saddr getf = do (f,(asymm,ret3)) <- runGet ((,) <$> getf <*> getOnionRequest) bs
+                         oaddr <- onionToOwner asymm ret3 saddr
+                         return (f asymm, oaddr)
 
 parseOnionAddr :: (SockAddr -> Nonce8 -> IO (Maybe (OnionDestination r)))
                   -> (ByteString, SockAddr)
@@ -187,14 +187,14 @@ parseOnionAddr lookupSender (msg,saddr)
 
 getOnionReply :: Word8 -> Maybe (Get (OnionMessage Encrypted))
 getOnionReply 0x84 = Just $ OnionAnnounceResponse <$> get <*> get <*> get
-getOnionReply 0x86 = Just $ OnionToRouteResponse <$> getOnionAssym
+getOnionReply 0x86 = Just $ OnionToRouteResponse <$> getOnionAsymm
 getOnionReply _    = Nothing
 
 putOnionMsg :: OnionMessage Encrypted -> Put
-putOnionMsg (OnionAnnounce                a) = putOnionAssym 0x83 (return ()) a
-putOnionMsg (OnionToRoute pubkey          a) = putOnionAssym 0x85 (putPublicKey pubkey) a
+putOnionMsg (OnionAnnounce                a) = putOnionAsymm 0x83 (return ()) a
+putOnionMsg (OnionToRoute pubkey          a) = putOnionAsymm 0x85 (putPublicKey pubkey) a
 putOnionMsg (OnionAnnounceResponse n8 n24 x) = put (0x84 :: Word8) >> put n8 >> put n24 >> put x
-putOnionMsg (OnionToRouteResponse         a) = putOnionAssym 0x86 (return ()) a
+putOnionMsg (OnionToRouteResponse         a) = putOnionAsymm 0x86 (return ()) a
 
 encodeOnionAddr :: (NodeInfo -> r -> IO (Maybe OnionRoute))
                    -> (OnionMessage Encrypted,OnionDestination r)
@@ -470,7 +470,7 @@ peelOnion :: Serialize (Addressed (Forwarding n t))
               -> Forwarding (S n) t
               -> Either String (Addressed (Forwarding n t))
 peelOnion crypto nonce (Forwarding k fwd) =
-    fmap runIdentity $ uncomposed $ decryptMessage (dhtKey crypto) nonce (Right $ Assym k nonce fwd)
+    fmap runIdentity $ uncomposed $ decryptMessage (dhtKey crypto) nonce (Right $ Asymm k nonce fwd)
 
 handleOnionResponse :: (KnownPeanoNat n, Sized (ReturnPath n), Serialize (ReturnPath n)) => proxy (S n) -> TransportCrypto -> SockAddr -> UDPTransport -> IO a -> OnionResponse (S n) -> IO a
 handleOnionResponse proxy crypto saddr udp kont (OnionResponse path msg) = do
@@ -499,13 +499,13 @@ instance S.Serialize AnnounceRequest where
     get = AnnounceRequest <$> S.get <*> S.get <*> S.get
     put (AnnounceRequest p s k) = S.put (p,s,k)
 
-getOnionRequest :: Sized msg => Get (Assym (Encrypted msg), ReturnPath N3)
+getOnionRequest :: Sized msg => Get (Asymm (Encrypted msg), ReturnPath N3)
 getOnionRequest = do
     -- Assumes return path is constant size so that we can isolate
     -- the variable-sized prefix.
     cnt <- remaining
     a <- isolate (case size :: Size (ReturnPath N3) of ConstSize n -> cnt - n)
-                 getAliasedAssym
+                 getAliasedAsymm
     path <- get
     return (a,path)
 
@@ -619,7 +619,7 @@ encrypt :: TransportCrypto -> OnionMessage Identity -> OnionDestination r -> IO
 encrypt crypto msg rpath = do
     (skey,pkey) <- selectKey crypto msg rpath -- source key
     let okey = onionKey rpath                 -- destination key
-    return ( transcode ( (. (runIdentity . either id assymData))
+    return ( transcode ( (. (runIdentity . either id asymmData))
                                          . encryptMessage skey okey)
                                        msg
            , rpath)
@@ -652,12 +652,12 @@ decryptMessage :: Serialize x =>
                   (SecretKey,PublicKey)
                   -> Nonce24
                   -> Either (PublicKey, Encrypted x)
-                            (Assym (Encrypted x))
+                            (Asymm (Encrypted x))
                   -> (Either String ∘ Identity) x
 decryptMessage crypto n arg = plain $ ToxCrypto.decrypt secret e
  where
     secret     = computeSharedSecret (fst crypto) sender n
-    (sender,e) = either id (senderKey &&& assymData) arg
+    (sender,e) = either id (senderKey &&& asymmData) arg
     plain      = Composed . fmap Identity . (>>= decodePlain)
 
 
@@ -668,12 +668,12 @@ sequenceMessage (OnionToRoute pub a)     = pure $ OnionToRoute pub a
 sequenceMessage (OnionToRouteResponse a) = pure $ OnionToRouteResponse a
 -- sequenceMessage (OnionToRouteResponse a) = fmap OnionToRouteResponse $ sequenceA $ fmap uncomposed a
 
-transcode :: forall f g. (forall a. Serialize a => Nonce24 -> Either (f a) (Assym (f a)) -> g a) -> OnionMessage f -> OnionMessage g
-transcode f (OnionAnnounce a)        = OnionAnnounce $ a { assymData = f (assymNonce a) (Right a) }
+transcode :: forall f g. (forall a. Serialize a => Nonce24 -> Either (f a) (Asymm (f a)) -> g a) -> OnionMessage f -> OnionMessage g
+transcode f (OnionAnnounce a)        = OnionAnnounce $ a { asymmData = f (asymmNonce a) (Right a) }
 transcode f (OnionAnnounceResponse n8 n24 dta) = OnionAnnounceResponse n8 n24 $ f n24 $ Left dta
 transcode f (OnionToRoute pub a)     = OnionToRoute pub     a
 transcode f (OnionToRouteResponse a) = OnionToRouteResponse a
--- transcode f (OnionToRouteResponse a) = OnionToRouteResponse $ a { assymData = f (assymNonce a) (Right a) }
+-- transcode f (OnionToRouteResponse a) = OnionToRouteResponse $ a { asymmData = f (asymmNonce a) (Right a) }
 
 
 data OnionRoute = OnionRoute
@@ -738,14 +738,14 @@ instance Show Rendezvous where
 parseDataToRoute
     :: TransportCrypto
          -> (OnionMessage Encrypted,OnionDestination r)
-         -> Either (Assym (Encrypted DataToRoute),Rendezvous) (OnionMessage Encrypted, OnionDestination r)
+         -> Either (Asymm (Encrypted DataToRoute),Rendezvous) (OnionMessage Encrypted, OnionDestination r)
 parseDataToRoute crypto (OnionToRouteResponse dta, od)
                             = Left ( dta
                                    , Rendezvous (onionAliasPublic crypto) $ onionNodeInfo od )
 parseDataToRoute _      msg = Right msg
 
 encodeDataToRoute :: TransportCrypto
-                     -> (Assym (Encrypted DataToRoute),Rendezvous)
+                     -> (Asymm (Encrypted DataToRoute),Rendezvous)
                      -> Maybe (OnionMessage Encrypted,OnionDestination r)
 encodeDataToRoute crypto (dta, Rendezvous pub ni)
     = Just ( OnionToRoute pub -- Public key of destination node
diff --git a/src/Network/Tox/Transport.hs b/src/Network/Tox/Transport.hs
index d915561f..59c0cf6f 100644
--- a/src/Network/Tox/Transport.hs
+++ b/src/Network/Tox/Transport.hs
@@ -24,7 +24,7 @@ toxTransport ::
           -> UDPTransport
           -> IO ( Transport String NodeInfo (DHTMessage Encrypted8)
                 , Transport String (OnionDestination RouteId) (OnionMessage Encrypted)
-                , Transport String Rendezvous (Assym (Encrypted DataToRoute))
+                , Transport String Rendezvous (Asymm (Encrypted DataToRoute))
                 , Transport String SockAddr NetCrypto )
 toxTransport crypto orouter closeLookup udp = do
     (dht,udp1) <- partitionTransport parseDHTAddr (Just . encodeDHTAddr) $ forwardOnions crypto udp