@libp2p/webtransport 5.0.51 → 6.0.0-55b7e5fea

package/src/muxer.ts

@@ -1,103 +1,79 @@
+import { AbstractStreamMuxer } from '@libp2p/utils'
 import { webtransportBiDiStreamToStream } from './stream.js'
-import { inertDuplex } from './utils/inert-duplex.js'
+import type { WebTransportStream } from './stream.ts'
 import type WebTransport from './webtransport.js'
-import type { Logger, Stream, StreamMuxer, StreamMuxerFactory, StreamMuxerInit } from '@libp2p/interface'
+import type { CreateStreamOptions, MultiaddrConnection, StreamMuxer, StreamMuxerFactory } from '@libp2p/interface'
 
-export interface WebTransportMuxerInit {
-  maxInboundStreams: number
-}
+const PROTOCOL = '/webtransport'
 
-export function webtransportMuxer (wt: Pick<WebTransport, 'close' | 'createBidirectionalStream'>, reader: ReadableStreamDefaultReader<WebTransportBidirectionalStream>, log: Logger, config: WebTransportMuxerInit): StreamMuxerFactory {
-  let streamIDCounter = 0
-  log = log.newScope('muxer')
+class WebTransportStreamMuxer extends AbstractStreamMuxer<WebTransportStream> {
+  private webTransport: WebTransport
+  private streamIDCounter: number
+  private reader: ReadableStreamDefaultReader<WebTransportBidirectionalStream>
 
-  return {
-    protocol: 'webtransport',
-    createStreamMuxer: (init?: StreamMuxerInit): StreamMuxer => {
-      // !TODO handle abort signal when WebTransport supports this.
-      const activeStreams: Stream[] = []
+  constructor (webTransport: WebTransport, maConn: MultiaddrConnection) {
+    super(maConn, {
+      protocol: PROTOCOL,
+      name: 'muxer'
+    })
 
-      Promise.resolve()
-        .then(async () => {
-          //! TODO unclear how to add backpressure here?
-          while (true) {
-            const { done, value: wtStream } = await reader.read()
+    this.webTransport = webTransport
+    this.streamIDCounter = 0
+    this.reader = this.webTransport.incomingBidirectionalStreams.getReader()
 
-            if (done) {
-              break
-            }
+    Promise.resolve()
+      .then(async () => {
+        //! TODO unclear how to add backpressure here?
+        while (true) {
+          const { done, value } = await this.reader.read()
 
-            if (activeStreams.length >= config.maxInboundStreams) {
-              log(`too many inbound streams open - ${activeStreams.length}/${config.maxInboundStreams}, closing new incoming stream`)
-              // We've reached our limit, close this stream.
-              wtStream.writable.close().catch((err: Error) => {
-                log.error(`failed to close inbound stream that crossed our maxInboundStream limit: ${err.message}`)
-              })
-              wtStream.readable.cancel().catch((err: Error) => {
-                log.error(`failed to close inbound stream that crossed our maxInboundStream limit: ${err.message}`)
-              })
-            } else {
-              const stream = await webtransportBiDiStreamToStream(
-                wtStream,
-                String(streamIDCounter++),
-                'inbound',
-                activeStreams,
-                init?.onStreamEnd,
-                log
-              )
-              activeStreams.push(stream)
-              init?.onIncomingStream?.(stream)
-            }
+          if (done || value == null) {
+            break
           }
-        })
-        .catch(err => {
-          log.error('could not create a new stream', err)
-        })
-
-      const muxer: StreamMuxer = {
-        protocol: 'webtransport',
-        streams: activeStreams,
-        newStream: async (name?: string): Promise<Stream> => {
-          log('new outgoing stream', name)
 
-          const wtStream = await wt.createBidirectionalStream()
-          const stream = await webtransportBiDiStreamToStream(wtStream, String(streamIDCounter++), init?.direction ?? 'outbound', activeStreams, init?.onStreamEnd, log)
-          activeStreams.push(stream)
-
-          return stream
-        },
+          this.onRemoteStream(
+            webtransportBiDiStreamToStream(
+              value,
+              String(this.streamIDCounter++),
+              'inbound',
+              this.log,
+              this.streamOptions
+            )
+          )
+        }
+      })
+      .catch(err => {
+        this.log.error('could not create a new stream - %e', err)
+      })
+  }
 
-        /**
-         * Close all tracked streams and stop the muxer
-         */
-        close: async () => {
-          log('closing webtransport muxer gracefully')
+  async onCreateStream (options: CreateStreamOptions): Promise<WebTransportStream> {
+    const wtStream = await this.webTransport.createBidirectionalStream()
+    options?.signal?.throwIfAborted()
 
-          try {
-            wt.close()
-          } catch (err: any) {
-            muxer.abort(err)
-          }
-        },
+    return webtransportBiDiStreamToStream(
+      wtStream,
+      String(this.streamIDCounter++),
+      'outbound',
+      this.log,
+      options
+    )
+  }
 
-        /**
-         * Abort all tracked streams and stop the muxer
-         */
-        abort: (err: Error) => {
-          log('closing webtransport muxer with err:', err)
+  onData (): void {
 
-          try {
-            wt.close()
-          } catch (err: any) {
-            log.error('webtransport session threw error during close', err)
-          }
-        },
+  }
 
-        // This stream muxer is webtransport native. Therefore it doesn't plug in with any other duplex.
-        ...inertDuplex()
-      }
+  sendReset (): void {
+    this.webTransport.close()
+  }
+}
 
-      return muxer
+export function webtransportMuxer (webTransport: WebTransport): StreamMuxerFactory {
+  return {
+    protocol: PROTOCOL,
+    createStreamMuxer (maConn: MultiaddrConnection): StreamMuxer {
+      return new WebTransportStreamMuxer(webTransport, maConn)
     }
   }
 }

package/src/session-to-conn.ts

@@ -0,0 +1,50 @@
+import { AbstractMultiaddrConnection } from '@libp2p/utils'
+import type { AbortOptions, MultiaddrConnection } from '@libp2p/interface'
+import type { AbstractMultiaddrConnectionInit, SendResult } from '@libp2p/utils'
+import type { Uint8ArrayList } from 'uint8arraylist'
+
+export interface WebTransportSessionMultiaddrConnectionInit extends Omit<AbstractMultiaddrConnectionInit, 'name' | 'stream'> {
+  cleanUpWTSession(metric: string): void
+}
+
+class WebTransportSessionMultiaddrConnection extends AbstractMultiaddrConnection {
+  private cleanUpWTSession: (metric: string) => void
+
+  constructor (init: WebTransportSessionMultiaddrConnectionInit) {
+    super(init)
+
+    this.cleanUpWTSession = init.cleanUpWTSession
+  }
+
+  sendData (data: Uint8ArrayList): SendResult {
+    return {
+      sentBytes: data.byteLength,
+      canSendMore: true
+    }
+  }
+
+  sendReset (): void {
+    this.cleanUpWTSession('abort')
+  }
+
+  async sendClose (options?: AbortOptions): Promise<void> {
+    this.cleanUpWTSession('close')
+    options?.signal?.throwIfAborted()
+  }
+
+  sendPause (): void {
+    // TODO: backpressure?
+  }
+
+  sendResume (): void {
+    // TODO: backpressure?
+  }
+}
+
+/**
+ * Convert a socket into a MultiaddrConnection
+ * https://github.com/libp2p/interface-transport#multiaddrconnection
+ */
+export const toMultiaddrConnection = (init: WebTransportSessionMultiaddrConnectionInit): MultiaddrConnection => {
+  return new WebTransportSessionMultiaddrConnection(init)
+}

package/src/stream.ts

@@ -1,85 +1,118 @@
-import { AbstractStream } from '@libp2p/utils/abstract-stream'
+import { AbstractStream } from '@libp2p/utils'
 import { raceSignal } from 'race-signal'
-import { Uint8ArrayList } from 'uint8arraylist'
-import type { AbortOptions, Direction, Logger, Stream } from '@libp2p/interface'
-import type { AbstractStreamInit } from '@libp2p/utils/abstract-stream'
+import type { AbortOptions, MessageStreamDirection, Logger, StreamOptions } from '@libp2p/interface'
+import type { AbstractStreamInit, SendResult } from '@libp2p/utils'
+import type { Uint8ArrayList } from 'uint8arraylist'
 
 interface WebTransportStreamInit extends AbstractStreamInit {
-  bidiStream: WebTransportBidirectionalStream
+  stream: WebTransportBidirectionalStream
 }
 
-class WebTransportStream extends AbstractStream {
+export class WebTransportStream extends AbstractStream {
   private readonly writer: WritableStreamDefaultWriter<Uint8Array>
   private readonly reader: ReadableStreamDefaultReader<Uint8Array>
 
   constructor (init: WebTransportStreamInit) {
     super(init)
 
-    this.writer = init.bidiStream.writable.getWriter()
-    this.reader = init.bidiStream.readable.getReader()
+    this.writer = init.stream.writable.getWriter()
+    this.reader = init.stream.readable.getReader()
 
+    void this.writer.closed
+      .then(() => {
+        this.log('writer closed gracefully')
+      })
+      .catch((err) => {
+        // chrome/ff send different messages
+        if (err.message.includes('STOP_SENDING') || err.message.includes('StopSending')) {
+          // err.code === 0 so we may be able to use this to detect remote close
+          // read instead?
+          this.onRemoteCloseRead()
+        } else if (err.message.includes('RESET_STREAM') || err.message.includes('Reset')) {
+          this.onRemoteReset()
+        } else {
+          this.log('writer close promise rejected - %e', err)
+        }
+      })
+
+    this.readData()
+  }
+
+  private readData (): void {
     Promise.resolve()
       .then(async () => {
         while (true) {
           const result = await this.reader.read()
 
+          if (result.value != null) {
+            this.onData(result.value)
+          }
+
           if (result.done) {
-            init.log('remote closed write')
+            this.log('remote closed write')
+            this.onRemoteCloseWrite()
             return
           }
 
-          if (result.value != null) {
-            this.sourcePush(new Uint8ArrayList(result.value))
+          if (this.readStatus === 'paused') {
+            break
           }
         }
       })
       .catch(err => {
-        init.log.error('error reading from stream', err)
         this.abort(err)
       })
       .finally(() => {
-        this.remoteCloseWrite()
-      })
-
-    void this.writer.closed
-      .then(() => {
-        init.log('writer closed')
+        this.reader.releaseLock()
       })
-      .catch((err) => {
-        init.log('writer close promise rejected', err)
-      })
-      .finally(() => {
-        this.remoteCloseRead()
-      })
-  }
-
-  sendNewStream (options?: AbortOptions | undefined): void {
-    // this is a no-op
   }
 
-  async sendData (buf: Uint8ArrayList, options?: AbortOptions): Promise<void> {
-    for (const chunk of buf) {
-      this.log('sendData waiting for writer to be ready')
-      await raceSignal(this.writer.ready, options?.signal)
-
-      // the streams spec recommends not waiting for data to be sent
-      // https://streams.spec.whatwg.org/#example-manual-write-dont-await
-      this.writer.write(chunk)
+  sendData (data: Uint8ArrayList): SendResult {
+    // the streams spec recommends not waiting for data to be sent
+    // https://streams.spec.whatwg.org/#example-manual-write-dont-await
+    for (const buf of data) {
+      this.writer.write(buf)
         .catch(err => {
-          this.log.error('error sending stream data', err)
+          this.abort(err)
         })
     }
+
+    this.log.trace('desired size after sending %d bytes is %d bytes', data.byteLength, this.writer.desiredSize)
+
+    // null means the stream has errored - https://streams.spec.whatwg.org/#writable-stream-default-writer-get-desired-size
+    if (this.writer.desiredSize == null) {
+      return {
+        sentBytes: data.byteLength,
+        canSendMore: false
+      }
+    }
+
+    const canSendMore = this.writer.desiredSize > 0
+
+    if (!canSendMore) {
+      this.writer.ready.then(() => {
+        this.safeDispatchEvent('drain')
+      }, (err) => {
+        this.abort(err)
+      })
+    }
+
+    return {
+      sentBytes: data.byteLength,
+      canSendMore
+    }
   }
 
-  async sendReset (options?: AbortOptions): Promise<void> {
-    this.log('sendReset aborting writer')
-    await raceSignal(this.writer.abort(), options?.signal)
-    this.log('sendReset aborted writer')
+  sendReset (err: Error): void {
+    this.writer.abort(err)
+      .catch(err => {
+        this.log.error('error aborting writer - %e', err)
+      })
   }
 
   async sendCloseWrite (options?: AbortOptions): Promise<void> {
     this.log('sendCloseWrite closing writer')
-    await raceSignal(this.writer.close(), options?.signal)
+    await raceSignal(this.writer.close().catch(() => {}), options?.signal)
     this.log('sendCloseWrite closed writer')
   }
 
@@ -88,23 +121,23 @@ class WebTransportStream extends AbstractStream {
     await raceSignal(this.reader.cancel(), options?.signal)
     this.log('sendCloseRead cancelled reader')
   }
+
+  sendPause (): void {
+
+  }
+
+  sendResume (): void {
+    this.readData()
+  }
 }
 
-export async function webtransportBiDiStreamToStream (bidiStream: WebTransportBidirectionalStream, streamId: string, direction: Direction, activeStreams: Stream[], onStreamEnd: undefined | ((s: Stream) => void), log: Logger): Promise<Stream> {
-  const stream = new WebTransportStream({
-    bidiStream,
+export function webtransportBiDiStreamToStream (stream: WebTransportBidirectionalStream, streamId: string, direction: MessageStreamDirection, log: Logger, options?: StreamOptions): WebTransportStream {
+  return new WebTransportStream({
+    ...options,
+    stream,
     id: streamId,
     direction,
     log: log.newScope(`${direction}:${streamId}`),
-    onEnd: () => {
-      const index = activeStreams.findIndex(s => s === stream)
-      if (index !== -1) {
-        activeStreams.splice(index, 1)
-      }
-
-      onStreamEnd?.(stream)
-    }
+    protocol: ''
   })
-
-  return stream
 }

package/src/utils/parse-multiaddr.ts

@@ -1,6 +1,6 @@
 import { InvalidMultiaddrError } from '@libp2p/interface'
 import { peerIdFromString } from '@libp2p/peer-id'
-import { protocols } from '@multiformats/multiaddr'
+import { getNetConfig } from '@libp2p/utils'
 import { WebTransport } from '@multiformats/multiaddr-matcher'
 import { bases, digest } from 'multiformats/basics'
 import type { PeerId } from '@libp2p/interface'
@@ -17,7 +17,7 @@ function decodeCerthashStr (s: string): MultihashDigest {
 export interface ParsedMultiaddr {
   url: string
   certhashes: MultihashDigest[]
-  remotePeer?: PeerId
+  remotePeer: PeerId
 }
 
 export function parseMultiaddr (ma: Multiaddr): ParsedMultiaddr {
@@ -25,20 +25,28 @@ export function parseMultiaddr (ma: Multiaddr): ParsedMultiaddr {
     throw new InvalidMultiaddrError('Invalid multiaddr, was not a WebTransport address')
   }
 
-  const parts = ma.stringTuples()
-  const certhashes = parts
-    .filter(([name, _]) => name === protocols('certhash').code)
-    .map(([_, value]) => decodeCerthashStr(value ?? ''))
+  const certhashes: MultihashDigest[] = []
+  let remotePeer: PeerId | undefined
 
-  // only take the first peer id in the multiaddr as it may be a relay
-  const remotePeer = parts
-    .filter(([name, _]) => name === protocols('p2p').code)
-    .map(([_, value]) => peerIdFromString(value ?? ''))[0]
+  for (const components of ma.getComponents()) {
+    if (components.name === 'certhash') {
+      certhashes.push(decodeCerthashStr(components.value ?? ''))
+    }
 
-  const opts = ma.toOptions()
+    // only take the first peer id in the multiaddr as it may be a relay
+    if (components.name === 'p2p' && remotePeer == null) {
+      remotePeer = peerIdFromString(components.value ?? '')
+    }
+  }
+
+  if (remotePeer == null) {
+    throw new InvalidMultiaddrError('Remote peer must be present in multiaddr')
+  }
+
+  const opts = getNetConfig(ma)
   let host = opts.host
 
-  if (opts.family === 6 && host?.includes(':')) {
+  if (opts.type === 'ip6' && host.includes(':')) {
     /**
      * This resolves cases where `new WebTransport()` fails to construct because of an invalid URL being passed.
      *

package/src/utils/webtransport-message-stream.ts

@@ -0,0 +1,69 @@
+import { AbstractMessageStream } from '@libp2p/utils'
+import { raceSignal } from 'race-signal'
+import type { AbortOptions } from '@libp2p/interface'
+import type { MessageStreamInit, SendResult } from '@libp2p/utils'
+import type { Uint8ArrayList } from 'uint8arraylist'
+
+export interface WebTransportMessageStreamInit extends MessageStreamInit {
+  stream: WebTransportBidirectionalStream
+}
+
+export class WebTransportMessageStream extends AbstractMessageStream {
+  private writer: WritableStreamDefaultWriter<any>
+  private reader: ReadableStreamDefaultReader<any>
+
+  constructor (init: WebTransportMessageStreamInit) {
+    super(init)
+
+    this.writer = init.stream.writable.getWriter()
+    this.reader = init.stream.readable.getReader()
+
+    Promise.resolve().then(async () => {
+      while (true) {
+        const { done, value } = await this.reader.read()
+
+        if (value != null) {
+          this.onData(value)
+        }
+
+        if (done) {
+          break
+        }
+      }
+    })
+      .catch(err => {
+        this.abort(err)
+      })
+  }
+
+  async close (options?: AbortOptions): Promise<void> {
+    await raceSignal(this.writer.close(), options?.signal)
+  }
+
+  sendData (data: Uint8ArrayList): SendResult {
+    this.writer.write(data.subarray())
+      .catch(err => {
+        this.abort(err)
+      })
+
+    return {
+      sentBytes: data.byteLength,
+      canSendMore: true
+    }
+  }
+
+  sendReset (err: Error): void {
+    this.writer.abort(err)
+      .catch(err => {
+        this.log.error('could not send reset - %e', err)
+      })
+  }
+
+  sendPause (): void {
+
+  }
+
+  sendResume (): void {
+
+  }
+}

package/dist/src/constants.d.ts

@@ -1,2 +0,0 @@
-export declare const MAX_INBOUND_STREAMS = 1000;
-//# sourceMappingURL=constants.d.ts.map

package/dist/src/constants.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB,OAAQ,CAAA"}

package/dist/src/constants.js

@@ -1,2 +0,0 @@
-export const MAX_INBOUND_STREAMS = 1_000;
-//# sourceMappingURL=constants.js.map

package/dist/src/constants.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/constants.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,mBAAmB,GAAG,KAAK,CAAA"}

package/dist/src/utils/inert-duplex.d.ts

@@ -1,3 +0,0 @@
-import type { Duplex } from 'it-stream-types';
-export declare function inertDuplex(): Duplex<any, any, any>;
-//# sourceMappingURL=inert-duplex.d.ts.map

package/dist/src/utils/inert-duplex.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"inert-duplex.d.ts","sourceRoot":"","sources":["../../../src/utils/inert-duplex.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAU,MAAM,iBAAiB,CAAA;AAGrD,wBAAgB,WAAW,IAAK,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAiBpD"}

package/dist/src/utils/inert-duplex.js

@@ -1,20 +0,0 @@
-// Duplex that does nothing. Needed to fulfill the interface
-export function inertDuplex() {
-    return {
-        source: {
-            [Symbol.asyncIterator]() {
-                return {
-                    async next() {
-                        // This will never resolve
-                        return new Promise(() => { });
-                    }
-                };
-            }
-        },
-        sink: async (source) => {
-            // This will never resolve
-            return new Promise(() => { });
-        }
-    };
-}
-//# sourceMappingURL=inert-duplex.js.map

package/dist/src/utils/inert-duplex.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"inert-duplex.js","sourceRoot":"","sources":["../../../src/utils/inert-duplex.ts"],"names":[],"mappings":"AAEA,4DAA4D;AAC5D,MAAM,UAAU,WAAW;IACzB,OAAO;QACL,MAAM,EAAE;YACN,CAAC,MAAM,CAAC,aAAa,CAAC;gBACpB,OAAO;oBACL,KAAK,CAAC,IAAI;wBACR,0BAA0B;wBAC1B,OAAO,IAAI,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAA;oBAC/B,CAAC;iBACF,CAAA;YACH,CAAC;SACF;QACD,IAAI,EAAE,KAAK,EAAE,MAAmB,EAAE,EAAE;YAClC,0BAA0B;YAC1B,OAAO,IAAI,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAA;QAC/B,CAAC;KACF,CAAA;AACH,CAAC"}

package/dist/typedoc-urls.json

@@ -1,14 +0,0 @@
-{
-  "WebTransportCertificate": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webtransport.WebTransportCertificate.html",
-  ".:WebTransportCertificate": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webtransport.WebTransportCertificate.html",
-  "WebTransportComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webtransport.WebTransportComponents.html",
-  ".:WebTransportComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webtransport.WebTransportComponents.html",
-  "WebTransportInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webtransport.WebTransportInit.html",
-  ".:WebTransportInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webtransport.WebTransportInit.html",
-  "WebTransportMetrics": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webtransport.WebTransportMetrics.html",
-  ".:WebTransportMetrics": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webtransport.WebTransportMetrics.html",
-  "WebTransportDialEvents": "https://libp2p.github.io/js-libp2p/types/_libp2p_webtransport.WebTransportDialEvents.html",
-  ".:WebTransportDialEvents": "https://libp2p.github.io/js-libp2p/types/_libp2p_webtransport.WebTransportDialEvents.html",
-  "webTransport": "https://libp2p.github.io/js-libp2p/functions/_libp2p_webtransport.webTransport.html",
-  ".:webTransport": "https://libp2p.github.io/js-libp2p/functions/_libp2p_webtransport.webTransport.html"
-}

package/src/constants.ts

@@ -1 +0,0 @@
-export const MAX_INBOUND_STREAMS = 1_000

package/src/utils/inert-duplex.ts

@@ -1,21 +0,0 @@
-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(() => { })
-    }
-  }
-}