@libp2p/webtransport 3.0.3 → 3.0.4-4ef9c79c

package/src/utils/inert-duplex.ts

@@ -0,0 +1,21 @@
+import type { Duplex, Source } from 'it-stream-types'
+
+// Duplex that does nothing. Needed to fulfill the interface
+export function inertDuplex (): Duplex<any, any, any> {
+  return {
+    source: {
+      [Symbol.asyncIterator] () {
+        return {
+          async next () {
+            // This will never resolve
+            return new Promise(() => { })
+          }
+        }
+      }
+    },
+    sink: async (source: Source<any>) => {
+      // This will never resolve
+      return new Promise(() => { })
+    }
+  }
+}

package/src/utils/is-subset.ts

@@ -0,0 +1,12 @@
+import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
+
+/**
+ * Determines if `maybeSubset` is a subset of `set`. This means that all byte
+ * arrays in `maybeSubset` are present in `set`.
+ */
+export function isSubset (set: Uint8Array[], maybeSubset: Uint8Array[]): boolean {
+  const intersection = maybeSubset.filter(byteArray => {
+    return Boolean(set.find((otherByteArray: Uint8Array) => uint8ArrayEquals(byteArray, otherByteArray)))
+  })
+  return (intersection.length === maybeSubset.length)
+}

package/src/utils/parse-multiaddr.ts

@@ -0,0 +1,83 @@
+import { peerIdFromString } from '@libp2p/peer-id'
+import { type Multiaddr, protocols } from '@multiformats/multiaddr'
+import { bases, digest } from 'multiformats/basics'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { MultihashDigest } from 'multiformats/hashes/interface'
+
+// @ts-expect-error - Not easy to combine these types.
+const multibaseDecoder = Object.values(bases).map(b => b.decoder).reduce((d, b) => d.or(b))
+
+function decodeCerthashStr (s: string): MultihashDigest {
+  return digest.decode(multibaseDecoder.decode(s))
+}
+
+export function parseMultiaddr (ma: Multiaddr): { url: string, certhashes: MultihashDigest[], remotePeer?: PeerId } {
+  const parts = ma.stringTuples()
+
+  // This is simpler to have inline than extract into a separate function
+  // eslint-disable-next-line complexity
+  const { url, certhashes, remotePeer } = parts.reduce((state: { url: string, certhashes: MultihashDigest[], seenHost: boolean, seenPort: boolean, remotePeer?: PeerId }, [proto, value]) => {
+    switch (proto) {
+      case protocols('ip6').code:
+      // @ts-expect-error - ts error on switch fallthrough
+      case protocols('dns6').code:
+        if (value?.includes(':') === true) {
+          /**
+           * This resolves cases where `new globalThis.WebTransport` fails to construct because of an invalid URL being passed.
+           *
+           * `new URL('https://::1:4001/blah')` will throw a `TypeError: Failed to construct 'URL': Invalid URL`
+           * `new URL('https://[::1]:4001/blah')` is valid and will not.
+           *
+           * @see https://datatracker.ietf.org/doc/html/rfc3986#section-3.2.2
+           */
+          value = `[${value}]`
+        }
+      // eslint-disable-next-line no-fallthrough
+      case protocols('ip4').code:
+      case protocols('dns4').code:
+        if (state.seenHost || state.seenPort) {
+          throw new Error('Invalid multiaddr, saw host and already saw the host or port')
+        }
+        return {
+          ...state,
+          url: `${state.url}${value ?? ''}`,
+          seenHost: true
+        }
+      case protocols('quic').code:
+      case protocols('quic-v1').code:
+      case protocols('webtransport').code:
+        if (!state.seenHost || !state.seenPort) {
+          throw new Error("Invalid multiaddr, Didn't see host and port, but saw quic/webtransport")
+        }
+        return state
+      case protocols('udp').code:
+        if (state.seenPort) {
+          throw new Error('Invalid multiaddr, saw port but already saw the port')
+        }
+        return {
+          ...state,
+          url: `${state.url}:${value ?? ''}`,
+          seenPort: true
+        }
+      case protocols('certhash').code:
+        if (!state.seenHost || !state.seenPort) {
+          throw new Error('Invalid multiaddr, saw the certhash before seeing the host and port')
+        }
+        return {
+          ...state,
+          certhashes: state.certhashes.concat([decodeCerthashStr(value ?? '')])
+        }
+      case protocols('p2p').code:
+        return {
+          ...state,
+          remotePeer: peerIdFromString(value ?? '')
+        }
+      default:
+        throw new Error(`unexpected component in multiaddr: ${proto} ${protocols(proto).name} ${value ?? ''} `)
+    }
+  },
+  // All webtransport urls are https
+  { url: 'https://', seenHost: false, seenPort: false, certhashes: [] })
+
+  return { url, certhashes, remotePeer }
+}

package/dist/typedoc-urls.json

@@ -1,6 +0,0 @@
-{
-  "WebTransportComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webtransport.WebTransportComponents.html",
-  "WebTransportInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webtransport.WebTransportInit.html",
-  "isSubset": "https://libp2p.github.io/js-libp2p/functions/_libp2p_webtransport.isSubset.html",
-  "webTransport": "https://libp2p.github.io/js-libp2p/functions/_libp2p_webtransport.webTransport.html"
-}