@libp2p/webtransport 4.0.28-c82432312 → 4.0.28-de3f7aeaf

package/src/index.ts

@@ -30,23 +30,38 @@
  */
 
 import { noise } from '@chainsafe/libp2p-noise'
-import { type Transport, transportSymbol, type CreateListenerOptions, type DialOptions, type Listener, type ComponentLogger, type Logger, type Connection, type MultiaddrConnection, type Stream, type CounterGroup, type Metrics, type PeerId, type StreamMuxerFactory, type StreamMuxerInit, type StreamMuxer } from '@libp2p/interface'
-import { type Multiaddr, type AbortOptions } from '@multiformats/multiaddr'
+import { AbortError, CodeError, transportSymbol } from '@libp2p/interface'
 import { WebTransport as WebTransportMatcher } from '@multiformats/multiaddr-matcher'
-import { webtransportBiDiStreamToStream } from './stream.js'
+import { raceSignal } from 'race-signal'
+import createListener from './listener.js'
+import { webtransportMuxer } from './muxer.js'
 import { inertDuplex } from './utils/inert-duplex.js'
 import { isSubset } from './utils/is-subset.js'
 import { parseMultiaddr } from './utils/parse-multiaddr.js'
+import WebTransport from './webtransport.js'
+import type { Transport, CreateListenerOptions, DialOptions, Listener, ComponentLogger, Logger, Connection, MultiaddrConnection, CounterGroup, Metrics, PeerId } from '@libp2p/interface'
+import type { Multiaddr } from '@multiformats/multiaddr'
 import type { Source } from 'it-stream-types'
 import type { MultihashDigest } from 'multiformats/hashes/interface'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
+/**
+ * PEM format server certificate and private key
+ */
+export interface WebTransportCertificate {
+  privateKey: string
+  pem: string
+  hash: MultihashDigest<number>
+  secret: string
+}
+
 interface WebTransportSessionCleanup {
   (metric: string): void
 }
 
 export interface WebTransportInit {
   maxInboundStreams?: number
+  certificates?: WebTransportCertificate[]
 }
 
 export interface WebTransportComponents {
@@ -69,7 +84,9 @@ class WebTransportTransport implements Transport {
     this.log = components.logger.forComponent('libp2p:webtransport')
     this.components = components
     this.config = {
-      maxInboundStreams: init.maxInboundStreams ?? 1000
+      ...init,
+      maxInboundStreams: init.maxInboundStreams ?? 1000,
+      certificates: init.certificates ?? []
     }
 
     if (components.metrics != null) {
@@ -87,12 +104,14 @@ class WebTransportTransport implements Transport {
   readonly [transportSymbol] = true
 
   async dial (ma: Multiaddr, options: DialOptions): Promise<Connection> {
-    options?.signal?.throwIfAborted()
+    if (options?.signal?.aborted === true) {
+      throw new AbortError()
+    }
 
     this.log('dialing %s', ma)
     const localPeer = this.components.peerId
     if (localPeer === undefined) {
-      throw new Error('Need a local peerid')
+      throw new CodeError('Need a local peerid', 'ERR_INVALID_PARAMETERS')
     }
 
     options = options ?? {}
@@ -100,11 +119,11 @@ class WebTransportTransport implements Transport {
     const { url, certhashes, remotePeer } = parseMultiaddr(ma)
 
     if (remotePeer == null) {
-      throw new Error('Need a target peerid')
+      throw new CodeError('Need a target peerid', 'ERR_INVALID_PARAMETERS')
     }
 
     if (certhashes.length === 0) {
-      throw new Error('Expected multiaddr to contain certhashes')
+      throw new CodeError('Expected multiaddr to contain certhashes', 'ERR_INVALID_PARAMETERS')
     }
 
     let abortListener: (() => void) | undefined
@@ -159,10 +178,12 @@ class WebTransportTransport implements Transport {
         once: true
       })
 
+      this.log('wait for session to be ready')
       await Promise.race([
         wt.closed,
         wt.ready
       ])
+      this.log('session became ready')
 
       ready = true
       this.metrics?.dialerEvents.increment({ ready: true })
@@ -175,15 +196,17 @@ class WebTransportTransport implements Transport {
           cleanUpWTSession('remote_close')
         })
 
-      if (!await this.authenticateWebTransport(wt, localPeer, remotePeer, certhashes)) {
-        throw new Error('Failed to authenticate webtransport')
+      authenticated = await raceSignal(this.authenticateWebTransport(wt, localPeer, remotePeer, certhashes), options.signal)
+
+      if (!authenticated) {
+        throw new CodeError('Failed to authenticate webtransport', 'ERR_AUTHENTICATION_FAILED')
       }
 
       this.metrics?.dialerEvents.increment({ open: true })
 
       maConn = {
         close: async () => {
-          this.log('Closing webtransport')
+          this.log('closing webtransport')
           cleanUpWTSession('close')
         },
         abort: (err: Error) => {
@@ -199,9 +222,11 @@ class WebTransportTransport implements Transport {
         ...inertDuplex()
       }
 
-      authenticated = true
-
-      return await options.upgrader.upgradeOutbound(maConn, { skipEncryption: true, muxerFactory: this.webtransportMuxer(wt), skipProtection: true })
+      return await options.upgrader.upgradeOutbound(maConn, {
+        skipEncryption: true,
+        muxerFactory: webtransportMuxer(wt, wt.incomingBidirectionalStreams.getReader(), this.components.logger, this.config),
+        skipProtection: true
+      })
     } catch (err: any) {
       this.log.error('caught wt session err', err)
 
@@ -221,11 +246,14 @@ class WebTransportTransport implements Transport {
     }
   }
 
-  async authenticateWebTransport (wt: InstanceType<typeof WebTransport>, localPeer: PeerId, remotePeer: PeerId, certhashes: Array<MultihashDigest<number>>): Promise<boolean> {
+  async authenticateWebTransport (wt: WebTransport, localPeer: PeerId, remotePeer: PeerId, certhashes: Array<MultihashDigest<number>>, signal?: AbortSignal): Promise<boolean> {
+    if (signal?.aborted === true) {
+      throw new AbortError()
+    }
+
     const stream = await wt.createBidirectionalStream()
     const writer = stream.writable.getWriter()
     const reader = stream.readable.getReader()
-    await writer.ready
 
     const duplex = {
       source: (async function * () {
@@ -241,13 +269,15 @@ class WebTransportTransport implements Transport {
           }
         }
       })(),
-      sink: async function (source: Source<Uint8Array | Uint8ArrayList>) {
+      sink: async (source: Source<Uint8Array | Uint8ArrayList>) => {
         for await (const chunk of source) {
-          if (chunk instanceof Uint8Array) {
-            await writer.write(chunk)
-          } else {
-            await writer.write(chunk.subarray())
-          }
+          await raceSignal(writer.ready, signal)
+
+          const buf = chunk instanceof Uint8Array ? chunk : chunk.subarray()
+
+          writer.write(buf).catch(err => {
+            this.log.error('could not write chunk during authentication of WebTransport stream', err)
+          })
         }
       }
     }
@@ -273,105 +303,12 @@ class WebTransportTransport implements Transport {
     return true
   }
 
-  webtransportMuxer (wt: WebTransport): StreamMuxerFactory {
-    let streamIDCounter = 0
-    const config = this.config
-    const self = this
-    return {
-      protocol: 'webtransport',
-      createStreamMuxer: (init?: StreamMuxerInit): StreamMuxer => {
-        // !TODO handle abort signal when WebTransport supports this.
-
-        if (typeof init === 'function') {
-          // The api docs say that init may be a function
-          init = { onIncomingStream: init }
-        }
-
-        const activeStreams: Stream[] = [];
-
-        (async function () {
-          //! TODO unclear how to add backpressure here?
-
-          const reader = wt.incomingBidirectionalStreams.getReader()
-          while (true) {
-            const { done, value: wtStream } = await reader.read()
-
-            if (done) {
-              break
-            }
-
-            if (activeStreams.length >= config.maxInboundStreams) {
-              // We've reached our limit, close this stream.
-              wtStream.writable.close().catch((err: Error) => {
-                self.log.error(`Failed to close inbound stream that crossed our maxInboundStream limit: ${err.message}`)
-              })
-              wtStream.readable.cancel().catch((err: Error) => {
-                self.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,
-                self.components.logger
-              )
-              activeStreams.push(stream)
-              init?.onIncomingStream?.(stream)
-            }
-          }
-        })().catch(() => {
-          this.log.error('WebTransport failed to receive incoming stream')
-        })
-
-        const muxer: StreamMuxer = {
-          protocol: 'webtransport',
-          streams: activeStreams,
-          newStream: async (name?: string): Promise<Stream> => {
-            const wtStream = await wt.createBidirectionalStream()
-
-            const stream = await webtransportBiDiStreamToStream(
-              wtStream,
-              String(streamIDCounter++),
-              init?.direction ?? 'outbound',
-              activeStreams,
-              init?.onStreamEnd,
-              self.components.logger
-            )
-            activeStreams.push(stream)
-
-            return stream
-          },
-
-          /**
-           * Close or abort all tracked streams and stop the muxer
-           */
-          close: async (options?: AbortOptions) => {
-            this.log('Closing webtransport muxer')
-
-            await Promise.all(
-              activeStreams.map(async s => s.close(options))
-            )
-          },
-          abort: (err: Error) => {
-            this.log('Aborting webtransport muxer with err:', err)
-
-            for (const stream of activeStreams) {
-              stream.abort(err)
-            }
-          },
-          // This stream muxer is webtransport native. Therefore it doesn't plug in with any other duplex.
-          ...inertDuplex()
-        }
-
-        return muxer
-      }
-    }
-  }
-
   createListener (options: CreateListenerOptions): Listener {
-    throw new Error('Webtransport servers are not supported in Node or the browser')
+    return createListener(this.components, {
+      ...options,
+      certificates: this.config.certificates,
+      maxInboundStreams: this.config.maxInboundStreams
+    })
   }
 
   /**

package/src/listener.browser.ts

@@ -0,0 +1,5 @@
+import type { CreateListenerOptions, Listener } from '@libp2p/interface'
+
+export default function createListener (options: CreateListenerOptions): Listener {
+  throw new Error('Not implemented')
+}

package/src/listener.ts

@@ -0,0 +1,19 @@
+import type { WebTransportCertificate } from './index.js'
+import type { Connection, Upgrader, Listener, CreateListenerOptions, PeerId, ComponentLogger, Metrics } from '@libp2p/interface'
+
+export interface WebTransportListenerComponents {
+  peerId: PeerId
+  logger: ComponentLogger
+  metrics?: Metrics
+}
+
+export interface WebTransportListenerInit extends CreateListenerOptions {
+  handler?(conn: Connection): void
+  upgrader: Upgrader
+  certificates?: WebTransportCertificate[]
+  maxInboundStreams?: number
+}
+
+export default function createListener (components: WebTransportListenerComponents, options: WebTransportListenerInit): Listener {
+  throw new Error('Only supported in browsers')
+}

package/src/muxer.ts

@@ -0,0 +1,95 @@
+import { webtransportBiDiStreamToStream } from './stream.js'
+import { inertDuplex } from './utils/inert-duplex.js'
+import type WebTransport from './webtransport.js'
+import type { ComponentLogger, Stream, StreamMuxer, StreamMuxerFactory, StreamMuxerInit } from '@libp2p/interface'
+
+export interface WebTransportMuxerInit {
+  maxInboundStreams: number
+}
+
+export function webtransportMuxer (wt: Pick<WebTransport, 'close' | 'createBidirectionalStream'>, reader: ReadableStreamDefaultReader<WebTransportBidirectionalStream>, logger: ComponentLogger, config: WebTransportMuxerInit): StreamMuxerFactory {
+  let streamIDCounter = 0
+  const log = logger.forComponent('libp2p:webtransport:muxer')
+
+  return {
+    protocol: 'webtransport',
+    createStreamMuxer: (init?: StreamMuxerInit): StreamMuxer => {
+      // !TODO handle abort signal when WebTransport supports this.
+
+      if (typeof init === 'function') {
+        // The api docs say that init may be a function
+        init = { onIncomingStream: init }
+      }
+
+      const activeStreams: Stream[] = []
+
+      void Promise.resolve().then(async () => {
+        //! TODO unclear how to add backpressure here?
+        while (true) {
+          const { done, value: wtStream } = await reader.read()
+
+          if (done) {
+            break
+          }
+
+          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,
+              logger
+            )
+            activeStreams.push(stream)
+            init?.onIncomingStream?.(stream)
+          }
+        }
+      })
+
+      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, logger)
+          activeStreams.push(stream)
+
+          return stream
+        },
+
+        /**
+         * Close all tracked streams and stop the muxer
+         */
+        close: async () => {
+          log('closing webtransport muxer gracefully')
+          wt.close()
+        },
+
+        /**
+         * Abort all tracked streams and stop the muxer
+         */
+        abort: (err: Error) => {
+          log('closing webtransport muxer with err:', err)
+          wt.close()
+        },
+
+        // This stream muxer is webtransport native. Therefore it doesn't plug in with any other duplex.
+        ...inertDuplex()
+      }
+
+      return muxer
+    }
+  }
+}

package/src/stream.ts

@@ -1,184 +1,110 @@
+import { AbstractStream, type AbstractStreamInit } from '@libp2p/utils/abstract-stream'
+import { raceSignal } from 'race-signal'
 import { Uint8ArrayList } from 'uint8arraylist'
 import type { AbortOptions, ComponentLogger, Direction, Stream } from '@libp2p/interface'
-import type { Source } from 'it-stream-types'
 
-export async function webtransportBiDiStreamToStream (bidiStream: WebTransportBidirectionalStream, streamId: string, direction: Direction, activeStreams: Stream[], onStreamEnd: undefined | ((s: Stream) => void), logger: ComponentLogger): Promise<Stream> {
-  const log = logger.forComponent(`libp2p:webtransport:stream:${direction}:${streamId}`)
-  const writer = bidiStream.writable.getWriter()
-  const reader = bidiStream.readable.getReader()
-  await writer.ready
-
-  function cleanupStreamFromActiveStreams (): void {
-    const index = activeStreams.findIndex(s => s === stream)
-    if (index !== -1) {
-      activeStreams.splice(index, 1)
-      stream.timeline.close = Date.now()
-      onStreamEnd?.(stream)
-    }
-  }
+interface WebTransportStreamInit extends AbstractStreamInit {
+  bidiStream: WebTransportBidirectionalStream
+}
 
-  let writerClosed = false
-  let readerClosed = false;
-  (async function () {
-    const err: Error | undefined = await writer.closed.catch((err: Error) => err)
-    if (err != null) {
-      const msg = err.message
-      if (!(msg.includes('aborted by the remote server') || msg.includes('STOP_SENDING'))) {
-        log.error(`WebTransport writer closed unexpectedly: streamId=${streamId} err=${err.message}`)
-      }
-    }
-    writerClosed = true
-    if (writerClosed && readerClosed) {
-      cleanupStreamFromActiveStreams()
-    }
-  })().catch(() => {
-    log.error('WebTransport failed to cleanup closed stream')
-  });
-
-  (async function () {
-    const err: Error | undefined = await reader.closed.catch((err: Error) => err)
-    if (err != null) {
-      log.error(`WebTransport reader closed unexpectedly: streamId=${streamId} err=${err.message}`)
-    }
-    readerClosed = true
-    if (writerClosed && readerClosed) {
-      cleanupStreamFromActiveStreams()
-    }
-  })().catch(() => {
-    log.error('WebTransport failed to cleanup closed stream')
-  })
+class WebTransportStream extends AbstractStream {
+  private readonly writer: WritableStreamDefaultWriter<Uint8Array>
+  private readonly reader: ReadableStreamDefaultReader<Uint8Array>
 
-  let sinkSunk = false
-  const stream: Stream = {
-    id: streamId,
-    status: 'open',
-    writeStatus: 'ready',
-    readStatus: 'ready',
-    abort (err: Error) {
-      if (!writerClosed) {
-        writer.abort(err)
-          .catch(err => {
-            log.error('could not abort stream', err)
-          })
-        writerClosed = true
-      }
-      readerClosed = true
-
-      this.status = 'aborted'
-      this.writeStatus = 'closed'
-      this.readStatus = 'closed'
-
-      this.timeline.reset =
-        this.timeline.close =
-        this.timeline.closeRead =
-        this.timeline.closeWrite = Date.now()
-
-      cleanupStreamFromActiveStreams()
-    },
-    async close (options?: AbortOptions) {
-      this.status = 'closing'
-
-      await Promise.all([
-        stream.closeRead(options),
-        stream.closeWrite(options)
-      ])
-
-      cleanupStreamFromActiveStreams()
-
-      this.status = 'closed'
-      this.timeline.close = Date.now()
-    },
-
-    async closeRead (options?: AbortOptions) {
-      if (!readerClosed) {
-        this.readStatus = 'closing'
-
-        try {
-          await reader.cancel()
-        } catch (err: any) {
-          if (err.toString().includes('RESET_STREAM') === true) {
-            writerClosed = true
-          }
-        }
+  constructor (init: WebTransportStreamInit) {
+    super(init)
 
-        this.timeline.closeRead = Date.now()
-        this.readStatus = 'closed'
+    this.writer = init.bidiStream.writable.getWriter()
+    this.reader = init.bidiStream.readable.getReader()
 
-        readerClosed = true
-      }
+    Promise.resolve().then(async () => {
+      while (true) {
+        const result = await this.reader.read()
 
-      if (writerClosed) {
-        cleanupStreamFromActiveStreams()
-      }
-    },
+        if (result.done) {
+          init.log('remote closed write')
+          return
+        }
 
-    async closeWrite (options?: AbortOptions) {
-      if (!writerClosed) {
-        writerClosed = true
+        if (result.value != null) {
+          this.sourcePush(new Uint8ArrayList(result.value))
+        }
+      }
+    })
+      .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')
+      })
+      .catch((err) => {
+        init.log('writer close promise rejected', err)
+      })
+      .finally(() => {
+        this.remoteCloseRead()
+      })
+  }
 
-        this.writeStatus = 'closing'
+  sendNewStream (options?: AbortOptions | undefined): void {
+    // this is a no-op
+  }
 
-        try {
-          await writer.close()
-        } catch (err: any) {
-          if (err.toString().includes('RESET_STREAM') === true) {
-            readerClosed = true
-          }
-        }
+  async sendData (buf: Uint8ArrayList, options?: AbortOptions): Promise<void> {
+    for await (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)
+        .catch(err => {
+          this.log.error('error sending stream data', err)
+        })
+    }
+  }
 
-        this.timeline.closeWrite = Date.now()
-        this.writeStatus = 'closed'
-      }
+  async sendReset (options?: AbortOptions): Promise<void> {
+    this.log('sendReset aborting writer')
+    await raceSignal(this.writer.abort(), options?.signal)
+    this.log('sendReset aborted writer')
+  }
 
-      if (readerClosed) {
-        cleanupStreamFromActiveStreams()
-      }
-    },
-    direction,
-    timeline: { open: Date.now() },
-    metadata: {},
-    source: (async function * () {
-      while (true) {
-        const val = await reader.read()
-        if (val.done) {
-          readerClosed = true
-          if (writerClosed) {
-            cleanupStreamFromActiveStreams()
-          }
-          return
-        }
+  async sendCloseWrite (options?: AbortOptions): Promise<void> {
+    this.log('sendCloseWrite closing writer')
+    await raceSignal(this.writer.close(), options?.signal)
+    this.log('sendCloseWrite closed writer')
+  }
 
-        yield new Uint8ArrayList(val.value)
-      }
-    })(),
-    sink: async function (source: Source<Uint8Array | Uint8ArrayList>) {
-      if (sinkSunk) {
-        throw new Error('sink already called on stream')
-      }
-      sinkSunk = true
-      try {
-        this.writeStatus = 'writing'
-
-        for await (const chunks of source) {
-          if (chunks instanceof Uint8Array) {
-            await writer.write(chunks)
-          } else {
-            for (const buf of chunks) {
-              await writer.write(buf)
-            }
-          }
-        }
+  async sendCloseRead (options?: AbortOptions): Promise<void> {
+    this.log('sendCloseRead cancelling reader')
+    await raceSignal(this.reader.cancel(), options?.signal)
+    this.log('sendCloseRead cancelled reader')
+  }
+}
 
-        this.writeStatus = 'done'
-      } finally {
-        this.timeline.closeWrite = Date.now()
-        this.writeStatus = 'closed'
+export async function webtransportBiDiStreamToStream (bidiStream: WebTransportBidirectionalStream, streamId: string, direction: Direction, activeStreams: Stream[], onStreamEnd: undefined | ((s: Stream) => void), logger: ComponentLogger): Promise<Stream> {
+  const log = logger.forComponent(`libp2p:webtransport:stream:${direction}:${streamId}`)
 
-        await stream.closeWrite()
+  const stream = new WebTransportStream({
+    bidiStream,
+    id: streamId,
+    direction,
+    log,
+    onEnd: () => {
+      const index = activeStreams.findIndex(s => s === stream)
+      if (index !== -1) {
+        activeStreams.splice(index, 1)
       }
-    },
-    log
-  }
+
+      onStreamEnd?.(stream)
+    }
+  })
 
   return stream
 }

package/src/utils/generate-certificates.browser.ts

@@ -0,0 +1,3 @@
+export async function generateWebTransportCertificates (): Promise<any> {
+  throw new Error('Not implemented')
+}