@libp2p/websockets 9.2.18 → 9.2.19-8484de8a2

package/src/index.ts

@@ -25,17 +25,14 @@
 
 import { transportSymbol, serviceCapabilities, ConnectionFailedError } from '@libp2p/interface'
 import { multiaddrToUri as toUri } from '@multiformats/multiaddr-to-uri'
-import { connect } from 'it-ws/client'
-import pDefer from 'p-defer'
+import { pEvent } from 'p-event'
 import { CustomProgressEvent } from 'progress-events'
-import { raceSignal } from 'race-signal'
 import * as filters from './filters.js'
 import { createListener } from './listener.js'
-import { socketToMaConn } from './socket-to-conn.js'
+import { webSocketToMaConn } from './websocket-to-conn.js'
 import type { Transport, MultiaddrFilter, CreateListenerOptions, DialTransportOptions, Listener, AbortOptions, ComponentLogger, Logger, Connection, OutboundConnectionUpgradeEvents, Metrics, CounterGroup, Libp2pEvents } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { WebSocketOptions } from 'it-ws/client'
-import type { DuplexWebSocket } from 'it-ws/duplex'
 import type { TypedEventTarget } from 'main-event'
 import type http from 'node:http'
 import type https from 'node:https'
@@ -50,6 +47,8 @@ export interface WebSocketsInit extends AbortOptions, WebSocketOptions {
 
   /**
    * Options used to create WebSockets
+   *
+   * @deprecated This option will be removed in a future release
    */
   websocket?: ClientOptions
 
@@ -70,6 +69,25 @@ export interface WebSocketsInit extends AbortOptions, WebSocketOptions {
    * @deprecated Use the `connectionManager.inboundUpgradeTimeout` libp2p config key instead
    */
   inboundConnectionUpgradeTimeout?: number
+
+  /**
+   * How large the outgoing [bufferedAmount](https://websockets.spec.whatwg.org/#dom-websocket-bufferedamount)
+   * property of incoming and outgoing websockets is allowed to get in bytes.
+   *
+   * If this limit is exceeded, backpressure will be applied to the writer.
+   *
+   * @default 4_194_304
+   */
+  maxBufferedAmount?: number
+
+  /**
+   * If the [bufferedAmount](https://websockets.spec.whatwg.org/#dom-websocket-bufferedamount)
+   * property of a WebSocket exceeds `maxBufferedAmount`, poll the field every
+   * this number of ms to see if the socket can accept new data.
+   *
+   * @default 500
+   */
+  bufferedAmountPollInterval?: number
 }
 
 export interface WebSocketsComponents {
@@ -121,10 +139,14 @@ class WebSockets implements Transport<WebSocketsDialEvents> {
     this.log('dialing %s', ma)
     options = options ?? {}
 
-    const socket = await this._connect(ma, options)
-    const maConn = socketToMaConn(socket, ma, {
-      logger: this.logger,
-      metrics: this.metrics?.dialerEvents
+    const maConn = webSocketToMaConn({
+      websocket: await this._connect(ma, options),
+      remoteAddr: ma,
+      metrics: this.metrics?.dialerEvents,
+      direction: 'outbound',
+      log: this.components.logger.forComponent('libp2p:websockets:connection'),
+      maxBufferedAmount: this.init.maxBufferedAmount,
+      bufferedAmountPollInterval: this.init.bufferedAmountPollInterval
     })
     this.log('new outbound connection %s', maConn.remoteAddr)
 
@@ -133,43 +155,35 @@ class WebSockets implements Transport<WebSocketsDialEvents> {
     return conn
   }
 
-  async _connect (ma: Multiaddr, options: DialTransportOptions<WebSocketsDialEvents>): Promise<DuplexWebSocket> {
+  async _connect (ma: Multiaddr, options: DialTransportOptions<WebSocketsDialEvents>): Promise<WebSocket> {
     options?.signal?.throwIfAborted()
 
-    const cOpts = ma.toOptions()
-    this.log('dialing %s:%s', cOpts.host, cOpts.port)
-
-    const errorPromise = pDefer()
-    const rawSocket = connect(toUri(ma), this.init)
-    rawSocket.socket.addEventListener('error', () => {
-      // the WebSocket.ErrorEvent type doesn't actually give us any useful
-      // information about what happened
-      // https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/error_event
-      const err = new ConnectionFailedError(`Could not connect to ${ma.toString()}`)
-      this.log.error('connection error:', err)
-      this.metrics?.dialerEvents.increment({ error: true })
-      errorPromise.reject(err)
-    })
+    const uri = toUri(ma)
+    this.log('create websocket connection to %s', uri)
+    const websocket = new WebSocket(uri)
+    websocket.binaryType = 'arraybuffer'
 
     try {
       options.onProgress?.(new CustomProgressEvent('websockets:open-connection'))
-      await raceSignal(Promise.race([rawSocket.connected(), errorPromise.promise]), options.signal)
+      await pEvent(websocket, 'open', options)
     } catch (err: any) {
       if (options.signal?.aborted) {
         this.metrics?.dialerEvents.increment({ abort: true })
+        throw new ConnectionFailedError(`Could not connect to ${uri}`)
+      } else {
+        this.metrics?.dialerEvents.increment({ error: true })
       }
 
-      rawSocket.close()
-        .catch(err => {
-          this.log.error('error closing raw socket', err)
-        })
+      try {
+        websocket.close()
+      } catch {}
 
       throw err
     }
 
     this.log('connected %s', ma)
     this.metrics?.dialerEvents.increment({ connect: true })
-    return rawSocket
+    return websocket
   }
 
   /**

package/src/listener.ts

@@ -1,18 +1,16 @@
 import http from 'node:http'
 import https from 'node:https'
 import net from 'node:net'
-import { getThinWaistAddresses } from '@libp2p/utils/get-thin-waist-addresses'
-import { ipPortToMultiaddr as toMultiaddr } from '@libp2p/utils/ip-port-to-multiaddr'
+import { getNetConfig, getThinWaistAddresses, ipPortToMultiaddr as toMultiaddr } from '@libp2p/utils'
 import { multiaddr } from '@multiformats/multiaddr'
 import { WebSockets, WebSocketsSecure } from '@multiformats/multiaddr-matcher'
-import duplex from 'it-ws/duplex'
 import { TypedEventEmitter, setMaxListeners } from 'main-event'
 import { pEvent } from 'p-event'
 import * as ws from 'ws'
-import { socketToMaConn } from './socket-to-conn.js'
+import { toWebSocket } from './utils.ts'
+import { webSocketToMaConn } from './websocket-to-conn.js'
 import type { ComponentLogger, Logger, Listener, ListenerEvents, CreateListenerOptions, CounterGroup, MetricGroup, Metrics, TLSCertificate, Libp2pEvents, Upgrader, MultiaddrConnection } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
-import type { DuplexWebSocket } from 'it-ws/duplex'
 import type { TypedEventTarget } from 'main-event'
 import type { EventEmitter } from 'node:events'
 import type { Server } from 'node:http'
@@ -31,6 +29,8 @@ export interface WebSocketListenerInit extends CreateListenerOptions {
   key?: string
   http?: http.ServerOptions
   https?: http.ServerOptions
+  maxBufferedAmount?: number
+  bufferedAmountPollInterval?: number
 }
 
 export interface WebSocketListenerMetrics {
@@ -40,8 +40,8 @@ export interface WebSocketListenerMetrics {
 }
 
 export class WebSocketListener extends TypedEventEmitter<ListenerEvents> implements Listener {
+  private components: WebSocketListenerComponents
   private readonly log: Logger
-  private readonly logger: ComponentLogger
   private readonly server: net.Server
   private readonly wsServer: ws.WebSocketServer
   private readonly metrics: WebSocketListenerMetrics
@@ -54,15 +54,19 @@ export class WebSocketListener extends TypedEventEmitter<ListenerEvents> impleme
   private https?: https.Server
   private addr?: string
   private listeningMultiaddr?: Multiaddr
+  private maxBufferedAmount?: number
+  private bufferedAmountPollInterval?: number
 
   constructor (components: WebSocketListenerComponents, init: WebSocketListenerInit) {
     super()
 
+    this.components = components
     this.log = components.logger.forComponent('libp2p:websockets:listener')
-    this.logger = components.logger
     this.upgrader = init.upgrader
     this.httpOptions = init.http
     this.httpsOptions = init.https ?? init.http
+    this.maxBufferedAmount = init.maxBufferedAmount
+    this.bufferedAmountPollInterval = init.bufferedAmountPollInterval
     this.sockets = new Set()
     this.shutdownController = new AbortController()
     setMaxListeners(Infinity, this.shutdownController.signal)
@@ -171,6 +175,7 @@ export class WebSocketListener extends TypedEventEmitter<ListenerEvents> impleme
 
   onWsServerConnection (socket: ws.WebSocket, req: http.IncomingMessage): void {
     let addr: string | ws.AddressInfo | null
+    socket.binaryType = 'arraybuffer'
 
     try {
       addr = this.server.address()
@@ -189,22 +194,18 @@ export class WebSocketListener extends TypedEventEmitter<ListenerEvents> impleme
       return
     }
 
-    const stream: DuplexWebSocket = {
-      ...duplex(socket, {
-        remoteAddress: req.socket.remoteAddress ?? '0.0.0.0',
-        remotePort: req.socket.remotePort ?? 0
-      }),
-      localAddress: addr.address,
-      localPort: addr.port
-    }
-
     let maConn: MultiaddrConnection
 
     try {
-      maConn = socketToMaConn(stream, toMultiaddr(stream.remoteAddress ?? '', stream.remotePort ?? 0), {
-        logger: this.logger,
+      maConn = webSocketToMaConn({
+        websocket: toWebSocket(socket),
+        remoteAddr: toMultiaddr(req.socket.remoteAddress ?? '0.0.0.0', req.socket.remotePort ?? 0).encapsulate('/ws'),
         metrics: this.metrics?.events,
-        metricPrefix: `${this.addr} `
+        metricPrefix: `${this.addr} `,
+        direction: 'inbound',
+        log: this.components.logger.forComponent('libp2p:websockets:connection'),
+        maxBufferedAmount: this.maxBufferedAmount,
+        bufferedAmountPollInterval: this.bufferedAmountPollInterval
       })
     } catch (err: any) {
       this.log.error('inbound connection failed', err)
@@ -222,11 +223,7 @@ export class WebSocketListener extends TypedEventEmitter<ListenerEvents> impleme
         this.log.error('inbound connection failed to upgrade - %e', err)
         this.metrics.errors?.increment({ [`${this.addr} inbound_upgrade`]: true })
 
-        await maConn.close()
-          .catch(err => {
-            this.log.error('inbound connection failed to close after upgrade failed', err)
-            this.metrics.errors?.increment({ [`${this.addr} inbound_closing_failed`]: true })
-          })
+        maConn.close()
       })
   }
 
@@ -249,12 +246,12 @@ export class WebSocketListener extends TypedEventEmitter<ListenerEvents> impleme
       this.https.addListener('tlsClientError', this.onTLSClientError.bind(this))
     }
 
-    const options = ma.toOptions()
-    this.addr = `${options.host}:${options.port}`
+    const config = getNetConfig(ma)
+    this.addr = `${config.host}:${config.port}`
 
     this.server.listen({
-      ...options,
-      ipv6Only: options.family === 6
+      ...config,
+      ipv6Only: config.type === 'ip6'
     })
 
     await new Promise<void>((resolve, reject) => {

package/src/utils.ts

@@ -0,0 +1,36 @@
+import type { WebSocket as WSSWebSocket } from 'ws'
+
+/**
+ * Adds properties/methods to a `WebSocket` instance from the `ws` module to be
+ * compatible with the `globalThis.WebSocket` API
+ */
+export function toWebSocket (ws: WSSWebSocket): WebSocket {
+  Object.defineProperty(ws, 'url', {
+    value: '',
+    writable: false
+  })
+
+  // @ts-expect-error not a WS/WebSocket method
+  ws.dispatchEvent = (evt: Event) => {
+    if (evt.type === 'close') {
+      ws.emit('close')
+    }
+
+    if (evt.type === 'open') {
+      ws.emit('open')
+    }
+
+    if (evt.type === 'message') {
+      const m = evt as MessageEvent
+      ws.emit('data', m.data)
+    }
+
+    if (evt.type === 'error') {
+      ws.emit('error', new Error('An error occurred'))
+    }
+    ws.emit(evt.type, evt)
+  }
+
+  // @ts-expect-error ws is now WebSocket
+  return ws
+}

package/src/websocket-to-conn.ts

@@ -0,0 +1,108 @@
+import { AbstractMultiaddrConnection, repeatingTask } from '@libp2p/utils'
+import { Uint8ArrayList } from 'uint8arraylist'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import type { AbortOptions, MultiaddrConnection } from '@libp2p/interface'
+import type { AbstractMultiaddrConnectionInit, RepeatingTask, SendResult } from '@libp2p/utils'
+
+const DEFAULT_MAX_BUFFERED_AMOUNT = 1024 * 1024 * 4
+const DEFAULT_BUFFERED_AMOUNT_POLL_INTERVAL = 10
+
+export interface WebSocketMultiaddrConnectionInit extends Omit<AbstractMultiaddrConnectionInit, 'name'> {
+  websocket: WebSocket
+  maxBufferedAmount?: number
+  bufferedAmountPollInterval?: number
+}
+
+class WebSocketMultiaddrConnection extends AbstractMultiaddrConnection {
+  private websocket: WebSocket
+  private maxBufferedAmount: number
+  private checkBufferedAmountTask: RepeatingTask
+
+  constructor (init: WebSocketMultiaddrConnectionInit) {
+    super(init)
+
+    this.websocket = init.websocket
+    this.maxBufferedAmount = init.maxBufferedAmount ?? DEFAULT_MAX_BUFFERED_AMOUNT
+    this.checkBufferedAmountTask = repeatingTask(this.checkBufferedAmount.bind(this), init.bufferedAmountPollInterval ?? DEFAULT_BUFFERED_AMOUNT_POLL_INTERVAL)
+
+    this.websocket.addEventListener('close', (evt) => {
+      this.log('closed - code %d, reason "%s", wasClean %s', evt.code, evt.reason, evt.wasClean)
+      this.checkBufferedAmountTask.stop()
+
+      if (!evt.wasClean) {
+        this.onRemoteReset()
+        return
+      }
+
+      this.onTransportClosed()
+    }, { once: true })
+
+    this.websocket.addEventListener('message', (evt) => {
+      try {
+        let buf: Uint8Array
+
+        if (typeof evt.data === 'string') {
+          buf = uint8ArrayFromString(evt.data)
+        } else if (evt.data instanceof ArrayBuffer) {
+          buf = new Uint8Array(evt.data, 0, evt.data.byteLength)
+        } else {
+          this.abort(new Error('Incorrect binary type'))
+          return
+        }
+
+        this.onData(buf)
+      } catch (err: any) {
+        this.log.error('error receiving data - %e', err)
+      }
+    })
+  }
+
+  sendData (data: Uint8ArrayList): SendResult {
+    for (const buf of data) {
+      this.websocket.send(buf)
+    }
+
+    const canSendMore = this.websocket.bufferedAmount < this.maxBufferedAmount
+
+    if (!canSendMore) {
+      this.checkBufferedAmountTask.start()
+    }
+
+    return {
+      sentBytes: data.byteLength,
+      canSendMore
+    }
+  }
+
+  sendReset (): void {
+    this.websocket.close(1006) // abnormal closure
+  }
+
+  async sendClose (options?: AbortOptions): Promise<void> {
+    this.websocket.close()
+    options?.signal?.throwIfAborted()
+  }
+
+  sendPause (): void {
+    // read backpressure is not supported
+  }
+
+  sendResume (): void {
+    // read backpressure is not supported
+  }
+
+  private checkBufferedAmount (): void {
+    this.log('buffered amount now %d', this.websocket.bufferedAmount)
+
+    if (this.websocket.bufferedAmount === 0) {
+      this.checkBufferedAmountTask.stop()
+      this.safeDispatchEvent('drain')
+    }
+  }
+}
+
+// Convert a stream into a MultiaddrConnection
+// https://github.com/libp2p/interface-transport#multiaddrconnection
+export function webSocketToMaConn (init: WebSocketMultiaddrConnectionInit): MultiaddrConnection {
+  return new WebSocketMultiaddrConnection(init)
+}

package/dist/src/socket-to-conn.d.ts

@@ -1,11 +0,0 @@
-import type { ComponentLogger, CounterGroup, MultiaddrConnection } from '@libp2p/interface';
-import type { Multiaddr } from '@multiformats/multiaddr';
-import type { DuplexWebSocket } from 'it-ws/duplex';
-export interface SocketToConnOptions {
-    localAddr?: Multiaddr;
-    logger: ComponentLogger;
-    metrics?: CounterGroup;
-    metricPrefix?: string;
-}
-export declare function socketToMaConn(stream: DuplexWebSocket, remoteAddr: Multiaddr, options: SocketToConnOptions): MultiaddrConnection;
-//# sourceMappingURL=socket-to-conn.d.ts.map

package/dist/src/socket-to-conn.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"socket-to-conn.d.ts","sourceRoot":"","sources":["../../src/socket-to-conn.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAgB,eAAe,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAA;AACzG,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACxD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAEnD,MAAM,WAAW,mBAAmB;IAClC,SAAS,CAAC,EAAE,SAAS,CAAA;IACrB,MAAM,EAAE,eAAe,CAAA;IACvB,OAAO,CAAC,EAAE,YAAY,CAAA;IACtB,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAID,wBAAgB,cAAc,CAAE,MAAM,EAAE,eAAe,EAAE,UAAU,EAAE,SAAS,EAAE,OAAO,EAAE,mBAAmB,GAAG,mBAAmB,CA6FjI"}

package/dist/src/socket-to-conn.js

@@ -1,83 +0,0 @@
-import { AbortError } from '@libp2p/interface';
-import { CLOSE_TIMEOUT } from './constants.js';
-// Convert a stream into a MultiaddrConnection
-// https://github.com/libp2p/interface-transport#multiaddrconnection
-export function socketToMaConn(stream, remoteAddr, options) {
-    const log = options.logger.forComponent('libp2p:websockets:maconn');
-    const metrics = options.metrics;
-    const metricPrefix = options.metricPrefix ?? '';
-    const maConn = {
-        log,
-        async sink(source) {
-            try {
-                await stream.sink((async function* () {
-                    for await (const buf of source) {
-                        if (buf instanceof Uint8Array) {
-                            yield buf;
-                        }
-                        else {
-                            yield buf.subarray();
-                        }
-                    }
-                })());
-            }
-            catch (err) {
-                if (err.type !== 'aborted') {
-                    log.error(err);
-                }
-            }
-        },
-        source: stream.source,
-        remoteAddr,
-        timeline: { open: Date.now() },
-        async close(options = {}) {
-            const start = Date.now();
-            if (options.signal == null) {
-                const signal = AbortSignal.timeout(CLOSE_TIMEOUT);
-                options = {
-                    ...options,
-                    signal
-                };
-            }
-            const listener = () => {
-                const { host, port } = maConn.remoteAddr.toOptions();
-                log('timeout closing stream to %s:%s after %dms, destroying it manually', host, port, Date.now() - start);
-                this.abort(new AbortError('Socket close timeout'));
-            };
-            options.signal?.addEventListener('abort', listener);
-            try {
-                await stream.close();
-            }
-            catch (err) {
-                log.error('error closing WebSocket gracefully', err);
-                this.abort(err);
-            }
-            finally {
-                options.signal?.removeEventListener('abort', listener);
-                maConn.timeline.close = Date.now();
-            }
-        },
-        abort(err) {
-            const { host, port } = maConn.remoteAddr.toOptions();
-            log('timeout closing stream to %s:%s due to error', host, port, err);
-            stream.destroy();
-            maConn.timeline.close = Date.now();
-            // ws WebSocket.terminate does not accept an Error arg to emit an 'error'
-            // event on destroy like other node streams so we can't update a metric
-            // with an event listener
-            // https://github.com/websockets/ws/issues/1752#issuecomment-622380981
-            metrics?.increment({ [`${metricPrefix}error`]: true });
-        }
-    };
-    stream.socket.addEventListener('close', () => {
-        metrics?.increment({ [`${metricPrefix}close`]: true });
-        // In instances where `close` was not explicitly called,
-        // such as an iterable stream ending, ensure we have set the close
-        // timeline
-        if (maConn.timeline.close == null) {
-            maConn.timeline.close = Date.now();
-        }
-    }, { once: true });
-    return maConn;
-}
-//# sourceMappingURL=socket-to-conn.js.map

package/dist/src/socket-to-conn.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"socket-to-conn.js","sourceRoot":"","sources":["../../src/socket-to-conn.ts"],"names":[],"mappings":"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"}

package/dist/typedoc-urls.json

@@ -1,20 +0,0 @@
-{
-  "all": "https://libp2p.github.io/js-libp2p/functions/_libp2p_websockets.filters.all.html",
-  "./filters:all": "https://libp2p.github.io/js-libp2p/functions/_libp2p_websockets.filters.all.html",
-  "dnsWsOrWss": "https://libp2p.github.io/js-libp2p/functions/_libp2p_websockets.filters.dnsWsOrWss.html",
-  "./filters:dnsWsOrWss": "https://libp2p.github.io/js-libp2p/functions/_libp2p_websockets.filters.dnsWsOrWss.html",
-  "dnsWss": "https://libp2p.github.io/js-libp2p/functions/_libp2p_websockets.filters.dnsWss.html",
-  "./filters:dnsWss": "https://libp2p.github.io/js-libp2p/functions/_libp2p_websockets.filters.dnsWss.html",
-  "wss": "https://libp2p.github.io/js-libp2p/functions/_libp2p_websockets.filters.wss.html",
-  "./filters:wss": "https://libp2p.github.io/js-libp2p/functions/_libp2p_websockets.filters.wss.html",
-  "WebSocketsComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_websockets.index.WebSocketsComponents.html",
-  ".:WebSocketsComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_websockets.index.WebSocketsComponents.html",
-  "WebSocketsInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_websockets.index.WebSocketsInit.html",
-  ".:WebSocketsInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_websockets.index.WebSocketsInit.html",
-  "WebSocketsMetrics": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_websockets.index.WebSocketsMetrics.html",
-  ".:WebSocketsMetrics": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_websockets.index.WebSocketsMetrics.html",
-  "WebSocketsDialEvents": "https://libp2p.github.io/js-libp2p/types/_libp2p_websockets.index.WebSocketsDialEvents.html",
-  ".:WebSocketsDialEvents": "https://libp2p.github.io/js-libp2p/types/_libp2p_websockets.index.WebSocketsDialEvents.html",
-  "webSockets": "https://libp2p.github.io/js-libp2p/functions/_libp2p_websockets.index.webSockets.html",
-  ".:webSockets": "https://libp2p.github.io/js-libp2p/functions/_libp2p_websockets.index.webSockets.html"
-}

package/src/socket-to-conn.ts

@@ -1,109 +0,0 @@
-import { AbortError } from '@libp2p/interface'
-import { CLOSE_TIMEOUT } from './constants.js'
-import type { AbortOptions, ComponentLogger, CounterGroup, MultiaddrConnection } from '@libp2p/interface'
-import type { Multiaddr } from '@multiformats/multiaddr'
-import type { DuplexWebSocket } from 'it-ws/duplex'
-
-export interface SocketToConnOptions {
-  localAddr?: Multiaddr
-  logger: ComponentLogger
-  metrics?: CounterGroup
-  metricPrefix?: string
-}
-
-// Convert a stream into a MultiaddrConnection
-// https://github.com/libp2p/interface-transport#multiaddrconnection
-export function socketToMaConn (stream: DuplexWebSocket, remoteAddr: Multiaddr, options: SocketToConnOptions): MultiaddrConnection {
-  const log = options.logger.forComponent('libp2p:websockets:maconn')
-  const metrics = options.metrics
-  const metricPrefix = options.metricPrefix ?? ''
-
-  const maConn: MultiaddrConnection = {
-    log,
-
-    async sink (source) {
-      try {
-        await stream.sink((async function * () {
-          for await (const buf of source) {
-            if (buf instanceof Uint8Array) {
-              yield buf
-            } else {
-              yield buf.subarray()
-            }
-          }
-        })())
-      } catch (err: any) {
-        if (err.type !== 'aborted') {
-          log.error(err)
-        }
-      }
-    },
-
-    source: stream.source,
-
-    remoteAddr,
-
-    timeline: { open: Date.now() },
-
-    async close (options: AbortOptions = {}) {
-      const start = Date.now()
-
-      if (options.signal == null) {
-        const signal = AbortSignal.timeout(CLOSE_TIMEOUT)
-
-        options = {
-          ...options,
-          signal
-        }
-      }
-
-      const listener = (): void => {
-        const { host, port } = maConn.remoteAddr.toOptions()
-        log('timeout closing stream to %s:%s after %dms, destroying it manually',
-          host, port, Date.now() - start)
-
-        this.abort(new AbortError('Socket close timeout'))
-      }
-
-      options.signal?.addEventListener('abort', listener)
-
-      try {
-        await stream.close()
-      } catch (err: any) {
-        log.error('error closing WebSocket gracefully', err)
-        this.abort(err)
-      } finally {
-        options.signal?.removeEventListener('abort', listener)
-        maConn.timeline.close = Date.now()
-      }
-    },
-
-    abort (err: Error): void {
-      const { host, port } = maConn.remoteAddr.toOptions()
-      log('timeout closing stream to %s:%s due to error',
-        host, port, err)
-
-      stream.destroy()
-      maConn.timeline.close = Date.now()
-
-      // ws WebSocket.terminate does not accept an Error arg to emit an 'error'
-      // event on destroy like other node streams so we can't update a metric
-      // with an event listener
-      // https://github.com/websockets/ws/issues/1752#issuecomment-622380981
-      metrics?.increment({ [`${metricPrefix}error`]: true })
-    }
-  }
-
-  stream.socket.addEventListener('close', () => {
-    metrics?.increment({ [`${metricPrefix}close`]: true })
-
-    // In instances where `close` was not explicitly called,
-    // such as an iterable stream ending, ensure we have set the close
-    // timeline
-    if (maConn.timeline.close == null) {
-      maConn.timeline.close = Date.now()
-    }
-  }, { once: true })
-
-  return maConn
-}