Use Opt instead of Option

libp2p/dial.nim

@@ -69,5 +69,5 @@ method addTransport*(
 method tryDial*(
   self: Dial,
   peerId: PeerId,
-  addrs: seq[MultiAddress]): Future[MultiAddress] {.async, base.} =
+  addrs: seq[MultiAddress]): Future[Opt[MultiAddress]] {.async, base.} =
   doAssert(false, "Not implemented!")

libp2p/dialer.nim

@@ -189,7 +189,7 @@ proc negotiateStream(
 method tryDial*(
   self: Dialer,
   peerId: PeerId,
-  addrs: seq[MultiAddress]): Future[MultiAddress] {.async.} =
+  addrs: seq[MultiAddress]): Future[Opt[MultiAddress]] {.async.} =
   ## Create a protocol stream in order to check
   ## if a connection is possible.
   ## Doesn't use the Connection Manager to save it.

libp2p/protocols/connectivity/autonat.nim

@@ -226,7 +226,10 @@ proc tryDial(a: Autonat, conn: Connection, addrs: seq[MultiAddress]) {.async.} =
   try:
     await a.sem.acquire()
     let ma = await a.switch.dialer.tryDial(conn.peerId, addrs)
-    await conn.sendResponseOk(ma)
+    if ma.isSome:
+      await conn.sendResponseOk(ma.get())
+    else:
+      await conn.sendResponseError(DialError, "Missing observed address")
   except CancelledError as exc:
     raise exc
   except CatchableError as exc:
@@ -241,15 +244,21 @@ proc handleDial(a: Autonat, conn: Connection, msg: AutonatMsg): Future[void] =
   if peerInfo.id.isSome() and peerInfo.id.get() != conn.peerId:
     return conn.sendResponseError(BadRequest, "PeerId mismatch")
 
-  var isRelayed = conn.observedAddr.contains(multiCodec("p2p-circuit"))
+  let observedAddr =
+    if conn.observedAddr.isNone:
+      return conn.sendResponseError(BadRequest, "Missing observed address")
+    else:
+      conn.observedAddr.get()
+
+  var isRelayed = observedAddr.contains(multiCodec("p2p-circuit"))
   if isRelayed.isErr() or isRelayed.get():
     return conn.sendResponseError(DialRefused, "Refused to dial a relayed observed address")
-  let hostIp = conn.observedAddr[0]
+  let hostIp = observedAddr[0]
   if hostIp.isErr() or not IP.match(hostIp.get()):
-    trace "wrong observed address", address=conn.observedAddr
+    trace "wrong observed address", address=observedAddr
     return conn.sendResponseError(InternalError, "Expected an IP address")
   var addrs = initHashSet[MultiAddress]()
-  addrs.incl(conn.observedAddr)
+  addrs.incl(observedAddr)
   for ma in peerInfo.addrs:
     isRelayed = ma.contains(multiCodec("p2p-circuit"))
     if isRelayed.isErr() or isRelayed.get():

libp2p/protocols/identify.nim

@@ -80,7 +80,7 @@ chronicles.expandIt(IdentifyInfo):
     if iinfo.signedPeerRecord.isSome(): "Some"
     else: "None"
 
-proc encodeMsg(peerInfo: PeerInfo, observedAddr: MultiAddress, sendSpr: bool): ProtoBuffer
+proc encodeMsg(peerInfo: PeerInfo, observedAddr: Opt[MultiAddress], sendSpr: bool): ProtoBuffer
   {.raises: [Defect].} =
   result = initProtoBuffer()
 
@@ -91,7 +91,8 @@ proc encodeMsg(peerInfo: PeerInfo, observedAddr: MultiAddress, sendSpr: bool): P
     result.write(2, ma.data.buffer)
   for proto in peerInfo.protocols:
     result.write(3, proto)
-  result.write(4, observedAddr.data.buffer)
+  if observedAddr.isSome:
+    result.write(4, observedAddr.get().data.buffer)
   let protoVersion = ProtoVersion
   result.write(5, protoVersion)
   let agentVersion = if peerInfo.agentVersion.len <= 0:

libp2p/protocols/pubsub/pubsubpeer.nim

@@ -174,7 +174,7 @@ proc connectOnce(p: PubSubPeer): Future[void] {.async.} =
 
     trace "Get new send connection", p, newConn
     p.sendConn = newConn
-    p.address = some(p.sendConn.observedAddr)
+    p.address = if p.sendConn.observedAddr.isSome: some(p.sendConn.observedAddr.get) else: none(MultiAddress)
 
     if p.onEvent != nil:
       p.onEvent(p, PubSubPeerEvent(kind: PubSubPeerEventKind.Connected))

libp2p/protocols/secure/secure.nim

@@ -48,7 +48,7 @@ chronicles.formatIt(SecureConn): shortLog(it)
 proc new*(T: type SecureConn,
            conn: Connection,
            peerId: PeerId,
-           observedAddr: MultiAddress,
+           observedAddr: Opt[MultiAddress],
            timeout: Duration = DefaultConnectionTimeout): T =
   result = T(stream: conn,
              peerId: peerId,

libp2p/stream/chronosstream.nim

@@ -60,7 +60,7 @@ proc init*(C: type ChronosStream,
            client: StreamTransport,
            dir: Direction,
            timeout = DefaultChronosStreamTimeout,
-           observedAddr: MultiAddress = MultiAddress()): ChronosStream =
+           observedAddr: Opt[MultiAddress]): ChronosStream =
   result = C(client: client,
              timeout: timeout,
              dir: dir,

libp2p/stream/connection.nim

@@ -37,7 +37,7 @@ type
     timerTaskFut: Future[void]      # the current timer instance
     timeoutHandler*: TimeoutHandler # timeout handler
     peerId*: PeerId
-    observedAddr*: MultiAddress
+    observedAddr*: Opt[MultiAddress]
     upgraded*: Future[void]
     protocol*: string               # protocol used by the connection, used as tag for metrics
     transportDir*: Direction        # The bottom level transport (generally the socket) direction
@@ -160,9 +160,9 @@ method getWrapped*(s: Connection): Connection {.base.} =
 proc new*(C: type Connection,
            peerId: PeerId,
            dir: Direction,
+           observedAddr: Opt[MultiAddress],
            timeout: Duration = DefaultConnectionTimeout,
-           timeoutHandler: TimeoutHandler = nil,
-           observedAddr: MultiAddress = MultiAddress()): Connection =
+           timeoutHandler: TimeoutHandler = nil): Connection =
   result = C(peerId: peerId,
              dir: dir,
              timeout: timeout,

libp2p/transports/tcptransport.nim

@@ -71,18 +71,20 @@ proc setupTcpTransportTracker(): TcpTransportTracker =
   result.isLeaked = leakTransport
   addTracker(TcpTransportTrackerName, result)
 
-proc connHandler*(self: TcpTransport,
-                  client: StreamTransport,
-                  dir: Direction): Future[Connection] {.async.} =
-  var observedAddr: MultiAddress = MultiAddress()
+proc getObservedAddr(client: StreamTransport): Future[MultiAddress] {.async.} =
   try:
-    observedAddr = MultiAddress.init(client.remoteAddress).tryGet()
+    return MultiAddress.init(client.remoteAddress).tryGet()
   except CatchableError as exc:
     trace "Failed to create observedAddr", exc = exc.msg
     if not(isNil(client) and client.closed):
       await client.closeWait()
     raise exc
 
+proc connHandler*(self: TcpTransport,
+                  client: StreamTransport,
+                  observedAddr: Opt[MultiAddress],
+                  dir: Direction): Future[Connection] {.async.} =
+
   trace "Handling tcp connection", address = $observedAddr,
                                    dir = $dir,
                                    clients = self.clients[Direction.In].len +
@@ -222,7 +224,8 @@ method accept*(self: TcpTransport): Future[Connection] {.async, gcsafe.} =
     self.acceptFuts[index] = self.servers[index].accept()
 
     let transp = await finished
-    return await self.connHandler(transp, Direction.In)
+    let observedAddr = await getObservedAddr(transp)
+    return await self.connHandler(transp, Opt.some(observedAddr), Direction.In)
   except TransportOsError as exc:
     # TODO: it doesn't sound like all OS errors
     # can  be ignored, we should re-raise those
@@ -250,7 +253,8 @@ method dial*(
 
   let transp = await connect(address)
   try:
-    return await self.connHandler(transp, Direction.Out)
+    let observedAddr = await getObservedAddr(transp)
+    return await self.connHandler(transp, Opt.some(observedAddr), Direction.Out)
   except CatchableError as err:
     await transp.closeWait()
     raise err

libp2p/transports/wstransport.nim

@@ -45,8 +45,8 @@ type
 proc new*(T: type WsStream,
            session: WSSession,
            dir: Direction,
-           timeout = 10.minutes,
-           observedAddr: MultiAddress = MultiAddress()): T =
+           observedAddr: Opt[MultiAddress],
+           timeout = 10.minutes): T =
 
   let stream = T(
     session: session,
@@ -221,8 +221,7 @@ proc connHandler(self: WsTransport,
         await stream.close()
       raise exc
 
-  let conn = WsStream.new(stream, dir)
-  conn.observedAddr = observedAddr
+  let conn = WsStream.new(stream, dir, Opt.some(observedAddr))
 
   self.connections[dir].add(conn)
   proc onClose() {.async.} =

tests/commontransport.nim

@@ -1,5 +1,6 @@
 {.used.}
 
+import std/options
 import sequtils
 import chronos, stew/byteutils
 import ../libp2p/[stream/connection,
@@ -35,14 +36,16 @@ proc commonTransportTest*(name: string, prov: TransportProvider, ma: string) =
 
       proc acceptHandler() {.async, gcsafe.} =
         let conn = await transport1.accept()
-        check transport1.handles(conn.observedAddr)
+        if conn.observedAddr.isSome():
+          check transport1.handles(conn.observedAddr.get())
         await conn.close()
 
       let handlerWait = acceptHandler()
 
       let conn = await transport2.dial(transport1.addrs[0])
 
-      check transport2.handles(conn.observedAddr)
+      if conn.observedAddr.isSome():
+        check transport2.handles(conn.observedAddr.get())
 
       await conn.close() #for some protocols, closing requires actively reading, so we must close here
 

tests/testconnmngr.nim

@@ -9,6 +9,9 @@ import ../libp2p/[connmanager,
 
 import helpers
 
+proc getConnection(peerId: PeerId, dir: Direction = Direction.In): Connection = 
+  return Connection.new(peerId, dir, Opt.none(MultiAddress))
+
 type
   TestMuxer = ref object of Muxer
     peerId: PeerId
@@ -18,7 +21,7 @@ method newStream*(
   name: string = "",
   lazy: bool = false):
   Future[Connection] {.async, gcsafe.} =
-  result = Connection.new(m.peerId, Direction.Out)
+  result = getConnection(m.peerId, Direction.Out)
 
 suite "Connection Manager":
   teardown:
@@ -27,7 +30,7 @@ suite "Connection Manager":
   asyncTest "add and retrieve a connection":
     let connMngr = ConnManager.new()
     let peerId = PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet()
-    let conn = Connection.new(peerId, Direction.In)
+    let conn = getConnection(peerId)
 
     connMngr.storeConn(conn)
     check conn in connMngr
@@ -41,7 +44,7 @@ suite "Connection Manager":
   asyncTest "shouldn't allow a closed connection":
     let connMngr = ConnManager.new()
     let peerId = PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet()
-    let conn = Connection.new(peerId, Direction.In)
+    let conn = getConnection(peerId)
     await conn.close()
 
     expect CatchableError:
@@ -52,7 +55,7 @@ suite "Connection Manager":
   asyncTest "shouldn't allow an EOFed connection":
     let connMngr = ConnManager.new()
     let peerId = PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet()
-    let conn = Connection.new(peerId, Direction.In)
+    let conn = getConnection(peerId)
     conn.isEof = true
 
     expect CatchableError:
@@ -64,7 +67,7 @@ suite "Connection Manager":
   asyncTest "add and retrieve a muxer":
     let connMngr = ConnManager.new()
     let peerId = PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet()
-    let conn = Connection.new(peerId, Direction.In)
+    let conn = getConnection(peerId)
     let muxer = new Muxer
     muxer.connection = conn
 
@@ -80,7 +83,7 @@ suite "Connection Manager":
   asyncTest "shouldn't allow a muxer for an untracked connection":
     let connMngr = ConnManager.new()
     let peerId = PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet()
-    let conn = Connection.new(peerId, Direction.In)
+    let conn = getConnection(peerId)
     let muxer = new Muxer
     muxer.connection = conn
 
@@ -94,8 +97,8 @@ suite "Connection Manager":
   asyncTest "get conn with direction":
     let connMngr = ConnManager.new()
     let peerId = PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet()
-    let conn1 = Connection.new(peerId, Direction.Out)
-    let conn2 = Connection.new(peerId, Direction.In)
+    let conn1 = getConnection(peerId, Direction.Out)
+    let conn2 = getConnection(peerId)
 
     connMngr.storeConn(conn1)
     connMngr.storeConn(conn2)
@@ -114,7 +117,7 @@ suite "Connection Manager":
   asyncTest "get muxed stream for peer":
     let connMngr = ConnManager.new()
     let peerId = PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet()
-    let conn = Connection.new(peerId, Direction.In)
+    let conn = getConnection(peerId)
 
     let muxer = new TestMuxer
     muxer.peerId = peerId
@@ -134,7 +137,7 @@ suite "Connection Manager":
   asyncTest "get stream from directed connection":
     let connMngr = ConnManager.new()
     let peerId = PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet()
-    let conn = Connection.new(peerId, Direction.In)
+    let conn = getConnection(peerId)
 
     let muxer = new TestMuxer
     muxer.peerId = peerId
@@ -155,7 +158,7 @@ suite "Connection Manager":
   asyncTest "get stream from any connection":
     let connMngr = ConnManager.new()
     let peerId = PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet()
-    let conn = Connection.new(peerId, Direction.In)
+    let conn = getConnection(peerId)
 
     let muxer = new TestMuxer
     muxer.peerId = peerId
@@ -175,11 +178,11 @@ suite "Connection Manager":
     let connMngr = ConnManager.new(maxConnsPerPeer = 1)
     let peerId = PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet()
 
-    connMngr.storeConn(Connection.new(peerId, Direction.In))
+    connMngr.storeConn(getConnection(peerId))
 
     let conns = @[
-        Connection.new(peerId, Direction.In),
-        Connection.new(peerId, Direction.In)]
+        getConnection(peerId),
+        getConnection(peerId)]
 
     expect TooManyConnectionsError:
       connMngr.storeConn(conns[0])
@@ -193,7 +196,7 @@ suite "Connection Manager":
   asyncTest "cleanup on connection close":
     let connMngr = ConnManager.new()
     let peerId = PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet()
-    let conn = Connection.new(peerId, Direction.In)
+    let conn = getConnection(peerId)
     let muxer = new Muxer
 
     muxer.connection = conn
@@ -220,7 +223,7 @@ suite "Connection Manager":
         Direction.In else:
         Direction.Out
 
-      let conn = Connection.new(peerId, dir)
+      let conn = getConnection(peerId, dir)
       let muxer = new Muxer
       muxer.connection = conn
 
@@ -353,7 +356,7 @@ suite "Connection Manager":
       let slot = await ((connMngr.getOutgoingSlot()).wait(10.millis))
 
       let conn =
-        Connection.new(
+        getConnection(
           PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet(),
           Direction.In)