Negotiate multiselect version for Muxer

`MuxerMultistream` is introduced to negotiate `Multiselect` version
before negotiating Multiplexer's version. This is required by
multistream 1.x

libp2p/transport/tcp/tcp.py

@@ -67,13 +67,14 @@ class TCP(ITransport):
         dial a transport to peer listening on multiaddr
         :param maddr: multiaddr of peer
         :param self_id: peer_id of the dialer (to send to receiver)
-        :return: True if successful
+        :return: `RawConnection` if successful
         """
         host = maddr.value_for_protocol("ip4")
         port = maddr.value_for_protocol("tcp")
 
         reader, writer = await asyncio.open_connection(host, int(port))
 
+        # TODO: Change this `sending peer id` process to `/plaintext/2.0.0`
         # First: send our peer ID so receiver knows it
         writer.write(self_id.to_base58().encode())
         await writer.drain()

libp2p/transport/upgrader.py

@@ -1,4 +1,4 @@
-from typing import Mapping, Sequence
+from typing import Mapping
 
 from libp2p.network.connection.raw_connection_interface import IRawConnection
 from libp2p.network.typing import GenericProtocolHandlerFn
@@ -6,7 +6,8 @@ from libp2p.peer.id import ID
 from libp2p.security.secure_conn_interface import ISecureConn
 from libp2p.security.secure_transport_interface import ISecureTransport
 from libp2p.security.security_multistream import SecurityMultistream
-from libp2p.stream_muxer.mplex.mplex import Mplex
+from libp2p.stream_muxer.abc import IMuxedConn
+from libp2p.stream_muxer.muxer_multistream import MuxerClassType, MuxerMultistream
 from libp2p.typing import TProtocol
 
 from .listener_interface import IListener
@@ -15,20 +16,21 @@ from .transport_interface import ITransport
 
 class TransportUpgrader:
     security_multistream: SecurityMultistream
-    muxer: Sequence[str]
+    muxer_multistream: MuxerMultistream
 
     def __init__(
         self,
         secure_transports_by_protocol: Mapping[TProtocol, ISecureTransport],
-        muxerOpt: Sequence[str],
+        muxer_transports_by_protocol: Mapping[TProtocol, MuxerClassType],
     ):
         self.security_multistream = SecurityMultistream(secure_transports_by_protocol)
-        self.muxer = muxerOpt
+        self.muxer_multistream = MuxerMultistream(muxer_transports_by_protocol)
 
     def upgrade_listener(self, transport: ITransport, listeners: IListener) -> None:
         """
         Upgrade multiaddr listeners to libp2p-transport listeners
         """
+        # TODO: Figure out what to do with this function.
         pass
 
     async def upgrade_security(
@@ -42,14 +44,15 @@ class TransportUpgrader:
 
         return await self.security_multistream.secure_inbound(raw_conn)
 
-    @staticmethod
-    def upgrade_connection(
+    async def upgrade_connection(
+        self,
         conn: ISecureConn,
         generic_protocol_handler: GenericProtocolHandlerFn,
         peer_id: ID,
-    ) -> Mplex:
+    ) -> IMuxedConn:
         """
-        Upgrade raw connection to muxed connection
+        Upgrade secured connection to be a muxed connection
         """
-        # TODO do exchange to determine multiplexer
-        return Mplex(conn, generic_protocol_handler, peer_id)
+        return await self.muxer_multistream.new_conn(
+            conn, generic_protocol_handler, peer_id
+        )