@libp2p/websockets 9.2.19 → 10.0.0-049bfa0fa

package/src/index.ts

@@ -24,35 +24,21 @@
  */
 
 import { transportSymbol, serviceCapabilities, ConnectionFailedError } from '@libp2p/interface'
+import { WebSockets as WebSocketsMatcher, WebSocketsSecure } from '@multiformats/multiaddr-matcher'
 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 type { Transport, MultiaddrFilter, CreateListenerOptions, DialTransportOptions, Listener, AbortOptions, ComponentLogger, Logger, Connection, OutboundConnectionUpgradeEvents, Metrics, CounterGroup, Libp2pEvents } from '@libp2p/interface'
+import { webSocketToMaConn } from './websocket-to-conn.js'
+import type { Transport, 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'
 import type { ProgressEvent } from 'progress-events'
-import type { ClientOptions } from 'ws'
 
 export interface WebSocketsInit extends AbortOptions, WebSocketOptions {
-  /**
-   * @deprecated Use a ConnectionGater instead
-   */
-  filter?: MultiaddrFilter
-
-  /**
-   * Options used to create WebSockets
-   */
-  websocket?: ClientOptions
-
   /**
    * Options used to create the HTTP server
    */
@@ -65,11 +51,23 @@ export interface WebSocketsInit extends AbortOptions, WebSocketOptions {
   https?: https.ServerOptions
 
   /**
-   * Inbound connections must complete their upgrade within this many ms
+   * 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.
    *
-   * @deprecated Use the `connectionManager.inboundUpgradeTimeout` libp2p config key instead
+   * @default 500
    */
-  inboundConnectionUpgradeTimeout?: number
+  bufferedAmountPollInterval?: number
 }
 
 export interface WebSocketsComponents {
@@ -121,10 +119,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 +135,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
   }
 
   /**
@@ -188,24 +182,10 @@ class WebSockets implements Transport<WebSocketsDialEvents> {
     })
   }
 
-  /**
-   * Takes a list of `Multiaddr`s and returns only valid WebSockets addresses.
-   * By default, in a browser environment only DNS+WSS multiaddr is accepted,
-   * while in a Node.js environment DNS+{WS, WSS} multiaddrs are accepted.
-   */
   listenFilter (multiaddrs: Multiaddr[]): Multiaddr[] {
-    multiaddrs = Array.isArray(multiaddrs) ? multiaddrs : [multiaddrs]
-
-    if (this.init?.filter != null) {
-      return this.init?.filter(multiaddrs)
-    }
-
-    return filters.all(multiaddrs)
+    return multiaddrs.filter(ma => WebSocketsMatcher.exactMatch(ma) || WebSocketsSecure.exactMatch(ma))
   }
 
-  /**
-   * Filter check for all Multiaddrs that this transport can dial
-   */
   dialFilter (multiaddrs: Multiaddr[]): Multiaddr[] {
     return this.listenFilter(multiaddrs)
   }

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) => {
@@ -334,12 +331,20 @@ export class WebSocketListener extends TypedEventEmitter<ListenerEvents> impleme
     // abort and in-flight connection upgrades
     this.shutdownController.abort()
 
-    await Promise.all([
+    const events = [
       pEvent(this.server, 'close'),
-      this.http == null ? null : pEvent(this.http, 'close'),
-      this.https == null ? null : pEvent(this.https, 'close'),
       pEvent(this.wsServer, 'close')
-    ])
+    ]
+
+    if (this.http != null) {
+      events.push(pEvent(this.http, 'close'))
+    }
+
+    if (this.https != null) {
+      events.push(pEvent(this.https, 'close'))
+    }
+
+    await Promise.all(events)
 
     this.safeDispatchEvent('close')
   }

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/filters.d.ts

@@ -1,18 +0,0 @@
-import type { Multiaddr } from '@multiformats/multiaddr';
-/**
- * @deprecated Configure this globally by passing a `connectionGater` to `createLibp2p` with a `denyDialMultiaddr` method that returns `false`
- */
-export declare function all(multiaddrs: Multiaddr[]): Multiaddr[];
-/**
- * @deprecated Configure this globally by passing a `connectionGater` to `createLibp2p`
- */
-export declare function wss(multiaddrs: Multiaddr[]): Multiaddr[];
-/**
- * @deprecated Configure this globally by passing a `connectionGater` to `createLibp2p`
- */
-export declare function dnsWss(multiaddrs: Multiaddr[]): Multiaddr[];
-/**
- * @deprecated Configure this globally by passing a `connectionGater` to `createLibp2p`
- */
-export declare function dnsWsOrWss(multiaddrs: Multiaddr[]): Multiaddr[];
-//# sourceMappingURL=filters.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"filters.d.ts","sourceRoot":"","sources":["../../src/filters.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAExD;;GAEG;AACH,wBAAgB,GAAG,CAAE,UAAU,EAAE,SAAS,EAAE,GAAG,SAAS,EAAE,CAIzD;AAED;;GAEG;AACH,wBAAgB,GAAG,CAAE,UAAU,EAAE,SAAS,EAAE,GAAG,SAAS,EAAE,CAIzD;AAED;;GAEG;AACH,wBAAgB,MAAM,CAAE,UAAU,EAAE,SAAS,EAAE,GAAG,SAAS,EAAE,CAI5D;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAE,UAAU,EAAE,SAAS,EAAE,GAAG,SAAS,EAAE,CAIhE"}

package/dist/src/filters.js

@@ -1,34 +0,0 @@
-import { WebSocketsSecure, WebSockets, DNS } from '@multiformats/multiaddr-matcher';
-/**
- * @deprecated Configure this globally by passing a `connectionGater` to `createLibp2p` with a `denyDialMultiaddr` method that returns `false`
- */
-export function all(multiaddrs) {
-    return multiaddrs.filter((ma) => {
-        return WebSocketsSecure.exactMatch(ma) || WebSockets.exactMatch(ma);
-    });
-}
-/**
- * @deprecated Configure this globally by passing a `connectionGater` to `createLibp2p`
- */
-export function wss(multiaddrs) {
-    return multiaddrs.filter((ma) => {
-        return WebSocketsSecure.exactMatch(ma);
-    });
-}
-/**
- * @deprecated Configure this globally by passing a `connectionGater` to `createLibp2p`
- */
-export function dnsWss(multiaddrs) {
-    return multiaddrs.filter((ma) => {
-        return DNS.matches(ma) && WebSocketsSecure.exactMatch(ma);
-    });
-}
-/**
- * @deprecated Configure this globally by passing a `connectionGater` to `createLibp2p`
- */
-export function dnsWsOrWss(multiaddrs) {
-    return multiaddrs.filter((ma) => {
-        return DNS.matches(ma) && (WebSocketsSecure.exactMatch(ma) || WebSockets.exactMatch(ma));
-    });
-}
-//# sourceMappingURL=filters.js.map

package/dist/src/filters.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"filters.js","sourceRoot":"","sources":["../../src/filters.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,iCAAiC,CAAA;AAGnF;;GAEG;AACH,MAAM,UAAU,GAAG,CAAE,UAAuB;IAC1C,OAAO,UAAU,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE;QAC9B,OAAO,gBAAgB,CAAC,UAAU,CAAC,EAAE,CAAC,IAAI,UAAU,CAAC,UAAU,CAAC,EAAE,CAAC,CAAA;IACrE,CAAC,CAAC,CAAA;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,GAAG,CAAE,UAAuB;IAC1C,OAAO,UAAU,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE;QAC9B,OAAO,gBAAgB,CAAC,UAAU,CAAC,EAAE,CAAC,CAAA;IACxC,CAAC,CAAC,CAAA;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,MAAM,CAAE,UAAuB;IAC7C,OAAO,UAAU,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE;QAC9B,OAAO,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,IAAI,gBAAgB,CAAC,UAAU,CAAC,EAAE,CAAC,CAAA;IAC3D,CAAC,CAAC,CAAA;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,UAAU,CAAE,UAAuB;IACjD,OAAO,UAAU,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE;QAC9B,OAAO,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,EAAE,CAAC,IAAI,UAAU,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC,CAAA;IAC1F,CAAC,CAAC,CAAA;AACJ,CAAC"}

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,CAkGjI"}

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

@@ -1,88 +0,0 @@
-import { AbortError, ConnectionFailedError } 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 metrics = options.metrics;
-    const metricPrefix = options.metricPrefix ?? '';
-    const maConn = {
-        log: options.logger.forComponent('libp2p:websockets:connection'),
-        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') {
-                    maConn.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();
-                maConn.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) {
-                maConn.log.error('error closing WebSocket gracefully - %e', err);
-                this.abort(err);
-            }
-            finally {
-                options.signal?.removeEventListener('abort', listener);
-                maConn.timeline.close = Date.now();
-            }
-        },
-        abort(err) {
-            maConn.log.error('destroying WebSocket after error - %e', 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 });
-        }
-    };
-    // track local vs remote closing
-    let closedLocally = false;
-    const close = stream.socket.close.bind(stream.socket);
-    stream.socket.close = (...args) => {
-        closedLocally = true;
-        return close(...args);
-    };
-    stream.socket.addEventListener('close', (evt) => {
-        maConn.log('closed %s, code %d, reason "%s", wasClean %s', closedLocally ? 'locally' : 'by remote', evt.code, evt.reason, evt.wasClean);
-        if (!evt.wasClean) {
-            maConn.abort(new ConnectionFailedError(`${closedLocally ? 'Local' : 'Remote'} did not close WebSocket cleanly`));
-            return;
-        }
-        metrics?.increment({ [`${metricPrefix}close`]: true });
-        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"
-}