Hardcoded transports

[DaughterOfZaun]

Trying to combine uTP transport and Bittorrent DHT discovery with LibP2P...

I noticed the hardcoded transports here and there.
Should I create an issue, or not embarrass myself?

const transportMatchers: Array<(ma: Multiaddr) => boolean> = [
  (ma: Multiaddr) => WebSockets.exactMatch(ma) || WebSocketsSecure.exactMatch(ma),
  (ma: Multiaddr) => TCP.exactMatch(ma),
  (ma: Multiaddr) => QUIC_V1.exactMatch(ma)
]

const _P2P = or(
  _WebSockets,
  _WebSocketsSecure,
  and(_TCP, optional(value(CODE_P2P))),
  and(QUIC_V0_OR_V1, optional(value(CODE_P2P))),
  and(_IP_OR_DOMAIN, optional(value(CODE_P2P))),
  _WebRTCDirect,
  _WebTransport,
  value(CODE_P2P)
)

It doesn't look very cool.

As I understand it, the root of all evil is Circuits, whose transport claims that it can dial anything, but it's not.

const _Circuit = and(_P2P, code(CODE_P2P_CIRCUIT), value(CODE_P2P))

/**
 * Filter check for all Multiaddrs that this transport can dial
 */
dialFilter (multiaddrs: Multiaddr[]): Multiaddr[] {
  multiaddrs = Array.isArray(multiaddrs) ? multiaddrs : [multiaddrs]
  return multiaddrs.filter((ma) => {
    return Circuit.exactMatch(ma)
  })
}

/**
 * Get the transport to dial a given multiaddr, if one has been configured
 */
dialTransportForMultiaddr (ma: Multiaddr): Transport | undefined {
  for (const transport of this.transports.values()) {
    const addrs = transport.dialFilter([ma])
    if (addrs.length > 0) {
      return transport
    }
  }
}

/**
 * Dials the given Multiaddr over it's supported transport
 */
async dial (ma: Multiaddr, options?: TransportManagerDialOptions): Promise<Connection> {
  const transport = this.dialTransportForMultiaddr(ma)
  /// ...
}

Therefore, to get the addresses that I can actually dial, I have to use something like

const transports = tm.getTransports().filter(transport => transport.constructor.name !== 'CircuitRelayTransport')
const multiaddrs = am.getAddresses().filter(ma => {
    const decapsulated = ma.decapsulateCode(CODE_P2P_CIRCUIT)
    return transports.some(transport => transport.dialFilter([ decapsulated ]).length > 0)
})

[achingbrain]

the root of all evil is Circuits, whose transport claims that it can dial anything, but it's not

Circuit relay is essentially a libp2p stream on top of an existing transport that's treated as a first-class connection, so if you add a uTP transport, circuit relay will be able to run on top of it without any extra modification.

The address has to have /p2p-circuit in it though, otherwise the circuit relay transport will not try to dial it.

---

It sounds like your dialFilter may be doing the wrong thing. It should accept a list of multiaddrs that libp2p is about to try and dial and it should return the subset of that list that the transport supports.

E.g. given a dial to a remote node that has the following addresses, this list will be passed to the dialFilter method of every configured transport:

[
  multiaddr('/ip4/123.123.123.123/tcp/1234/p2p/QmFoo),
  multiaddr('/ip4/123.123.123.123/tcp/1234/ws/p2p/QmFoo),
  multiaddr('/ip4/123.123.123.123/udp/1234/webrtc-direct/p2p/QmFoo)
]

The tcp transport dialFilter method would return:

[
  multiaddr('/ip4/123.123.123.123/tcp/1234/p2p/QmFoo)
]

...the websocket transport dialFilter method would return:

[
  multiaddr('/ip4/123.123.123.123/tcp/1234/ws/p2p/QmFoo)
]

...and so on.

The filtered multiaddr(s) will later be passed to the transport's dial method.