@libp2p/websockets 9.2.19-6059227cb → 9.2.19-87bc8d4fb

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@libp2p/websockets",
-  "version": "9.2.19-6059227cb",
+  "version": "9.2.19-87bc8d4fb",
   "description": "JavaScript implementation of the WebSockets module that libp2p uses and that implements the interface-transport spec",
   "license": "Apache-2.0 OR MIT",
   "homepage": "https://github.com/libp2p/js-libp2p/tree/main/packages/transport-websockets#readme",
@@ -67,28 +67,27 @@
     "test:electron-main": "aegir test -t electron-main -f ./dist/test/node.js --cov"
   },
   "dependencies": {
-    "@libp2p/interface": "2.11.0-6059227cb",
-    "@libp2p/utils": "6.7.2-6059227cb",
-    "@multiformats/multiaddr": "^13.0.1",
-    "@multiformats/multiaddr-matcher": "^3.0.1",
-    "@multiformats/multiaddr-to-uri": "^12.0.0",
+    "@libp2p/interface": "2.11.0-87bc8d4fb",
+    "@libp2p/utils": "6.7.2-87bc8d4fb",
+    "@multiformats/multiaddr": "^12.4.4",
+    "@multiformats/multiaddr-matcher": "^2.0.0",
+    "@multiformats/multiaddr-to-uri": "^11.0.0",
     "@types/ws": "^8.18.1",
     "it-ws": "^6.1.5",
     "main-event": "^1.0.1",
+    "p-defer": "^4.0.1",
     "p-event": "^6.0.1",
     "progress-events": "^1.0.1",
-    "uint8arraylist": "^2.4.8",
-    "uint8arrays": "^5.1.0",
-    "ws": "^8.18.3"
+    "race-signal": "^1.1.3",
+    "ws": "^8.18.2"
   },
   "devDependencies": {
-    "@libp2p/logger": "5.2.0-6059227cb",
-    "aegir": "^47.0.22",
+    "@libp2p/logger": "5.2.0-87bc8d4fb",
+    "aegir": "^47.0.14",
     "is-loopback-addr": "^2.0.2",
     "p-wait-for": "^5.0.2",
-    "sinon": "^21.0.0",
-    "sinon-ts": "^2.0.0",
-    "undici": "^7.15.0"
+    "sinon": "^20.0.0",
+    "sinon-ts": "^2.0.0"
   },
   "browser": {
     "./dist/src/listener.js": "./dist/src/listener.browser.js"

package/src/filters.ts

@@ -0,0 +1,38 @@
+import { WebSocketsSecure, WebSockets, DNS } from '@multiformats/multiaddr-matcher'
+import type { Multiaddr } from '@multiformats/multiaddr'
+
+/**
+ * @deprecated Configure this globally by passing a `connectionGater` to `createLibp2p` with a `denyDialMultiaddr` method that returns `false`
+ */
+export function all (multiaddrs: Multiaddr[]): Multiaddr[] {
+  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: Multiaddr[]): Multiaddr[] {
+  return multiaddrs.filter((ma) => {
+    return WebSocketsSecure.exactMatch(ma)
+  })
+}
+
+/**
+ * @deprecated Configure this globally by passing a `connectionGater` to `createLibp2p`
+ */
+export function dnsWss (multiaddrs: Multiaddr[]): Multiaddr[] {
+  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: Multiaddr[]): Multiaddr[] {
+  return multiaddrs.filter((ma) => {
+    return DNS.matches(ma) && (WebSocketsSecure.exactMatch(ma) || WebSockets.exactMatch(ma))
+  })
+}

package/src/index.ts

@@ -24,21 +24,35 @@
  */
 
 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 { pEvent } from 'p-event'
+import { connect } from 'it-ws/client'
+import pDefer from 'p-defer'
 import { CustomProgressEvent } from 'progress-events'
+import { raceSignal } from 'race-signal'
+import * as filters from './filters.js'
 import { createListener } from './listener.js'
-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 { 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 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
    */
@@ -51,23 +65,11 @@ export interface WebSocketsInit extends AbortOptions, WebSocketOptions {
   https?: https.ServerOptions
 
   /**
-   * 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.
+   * Inbound connections must complete their upgrade within this many ms
    *
-   * @default 500
+   * @deprecated Use the `connectionManager.inboundUpgradeTimeout` libp2p config key instead
    */
-  bufferedAmountPollInterval?: number
+  inboundConnectionUpgradeTimeout?: number
 }
 
 export interface WebSocketsComponents {
@@ -119,14 +121,10 @@ class WebSockets implements Transport<WebSocketsDialEvents> {
     this.log('dialing %s', ma)
     options = options ?? {}
 
-    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
+    const socket = await this._connect(ma, options)
+    const maConn = socketToMaConn(socket, ma, {
+      logger: this.logger,
+      metrics: this.metrics?.dialerEvents
     })
     this.log('new outbound connection %s', maConn.remoteAddr)
 
@@ -135,35 +133,43 @@ class WebSockets implements Transport<WebSocketsDialEvents> {
     return conn
   }
 
-  async _connect (ma: Multiaddr, options: DialTransportOptions<WebSocketsDialEvents>): Promise<WebSocket> {
+  async _connect (ma: Multiaddr, options: DialTransportOptions<WebSocketsDialEvents>): Promise<DuplexWebSocket> {
     options?.signal?.throwIfAborted()
 
-    const uri = toUri(ma)
-    this.log('create websocket connection to %s', uri)
-    const websocket = new WebSocket(uri)
-    websocket.binaryType = 'arraybuffer'
+    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)
+    })
 
     try {
       options.onProgress?.(new CustomProgressEvent('websockets:open-connection'))
-      await pEvent(websocket, 'open', options)
+      await raceSignal(Promise.race([rawSocket.connected(), errorPromise.promise]), options.signal)
     } 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 })
       }
 
-      try {
-        websocket.close()
-      } catch {}
+      rawSocket.close()
+        .catch(err => {
+          this.log.error('error closing raw socket', err)
+        })
 
       throw err
     }
 
     this.log('connected %s', ma)
     this.metrics?.dialerEvents.increment({ connect: true })
-    return websocket
+    return rawSocket
   }
 
   /**
@@ -182,10 +188,24 @@ 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[] {
-    return multiaddrs.filter(ma => WebSocketsMatcher.exactMatch(ma) || WebSocketsSecure.exactMatch(ma))
+    multiaddrs = Array.isArray(multiaddrs) ? multiaddrs : [multiaddrs]
+
+    if (this.init?.filter != null) {
+      return this.init?.filter(multiaddrs)
+    }
+
+    return filters.all(multiaddrs)
   }
 
+  /**
+   * Filter check for all Multiaddrs that this transport can dial
+   */
   dialFilter (multiaddrs: Multiaddr[]): Multiaddr[] {
     return this.listenFilter(multiaddrs)
   }

package/src/listener.ts

@@ -1,16 +1,18 @@
 import http from 'node:http'
 import https from 'node:https'
 import net from 'node:net'
-import { getNetConfig, getThinWaistAddresses, ipPortToMultiaddr as toMultiaddr } from '@libp2p/utils'
+import { getThinWaistAddresses } from '@libp2p/utils/get-thin-waist-addresses'
+import { ipPortToMultiaddr as toMultiaddr } from '@libp2p/utils/ip-port-to-multiaddr'
 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 { toWebSocket } from './utils.ts'
-import { webSocketToMaConn } from './websocket-to-conn.js'
+import { socketToMaConn } from './socket-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'
@@ -29,8 +31,6 @@ 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,19 +54,15 @@ 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)
@@ -175,7 +171,6 @@ 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()
@@ -194,18 +189,22 @@ 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 = webSocketToMaConn({
-        websocket: toWebSocket(socket),
-        remoteAddr: toMultiaddr(req.socket.remoteAddress ?? '0.0.0.0', req.socket.remotePort ?? 0).encapsulate('/ws'),
+      maConn = socketToMaConn(stream, toMultiaddr(stream.remoteAddress ?? '', stream.remotePort ?? 0), {
+        logger: this.logger,
         metrics: this.metrics?.events,
-        metricPrefix: `${this.addr} `,
-        direction: 'inbound',
-        log: this.components.logger.forComponent('libp2p:websockets:connection'),
-        maxBufferedAmount: this.maxBufferedAmount,
-        bufferedAmountPollInterval: this.bufferedAmountPollInterval
+        metricPrefix: `${this.addr} `
       })
     } catch (err: any) {
       this.log.error('inbound connection failed', err)
@@ -223,7 +222,11 @@ 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 })
 
-        maConn.close()
+        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 })
+          })
       })
   }
 
@@ -246,12 +249,12 @@ export class WebSocketListener extends TypedEventEmitter<ListenerEvents> impleme
       this.https.addListener('tlsClientError', this.onTLSClientError.bind(this))
     }
 
-    const config = getNetConfig(ma)
-    this.addr = `${config.host}:${config.port}`
+    const options = ma.toOptions()
+    this.addr = `${options.host}:${options.port}`
 
     this.server.listen({
-      ...config,
-      ipv6Only: config.type === 'ip6'
+      ...options,
+      ipv6Only: options.family === 6
     })
 
     await new Promise<void>((resolve, reject) => {
@@ -331,20 +334,14 @@ export class WebSocketListener extends TypedEventEmitter<ListenerEvents> impleme
     // abort and in-flight connection upgrades
     this.shutdownController.abort()
 
-    const events = [
+    await Promise.all([
       pEvent(this.server, 'close'),
+      // eslint-disable-next-line @typescript-eslint/await-thenable
+      this.http == null ? null : pEvent(this.http, 'close'),
+      // eslint-disable-next-line @typescript-eslint/await-thenable
+      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/socket-to-conn.ts

@@ -0,0 +1,114 @@
+import { AbortError, ConnectionFailedError } 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 metrics = options.metrics
+  const metricPrefix = options.metricPrefix ?? ''
+
+  const maConn: MultiaddrConnection = {
+    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: any) {
+        if (err.type !== 'aborted') {
+          maConn.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()
+        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: any) {
+        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: Error): void {
+      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
+}

package/dist/src/utils.d.ts

@@ -1,7 +0,0 @@
-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 declare function toWebSocket(ws: WSSWebSocket): WebSocket;
-//# sourceMappingURL=utils.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,IAAI,YAAY,EAAE,MAAM,IAAI,CAAA;AAEnD;;;GAGG;AACH,wBAAgB,WAAW,CAAE,EAAE,EAAE,YAAY,GAAG,SAAS,CA6BxD"}

package/dist/src/utils.js

@@ -1,30 +0,0 @@
-/**
- * Adds properties/methods to a `WebSocket` instance from the `ws` module to be
- * compatible with the `globalThis.WebSocket` API
- */
-export function toWebSocket(ws) {
-    Object.defineProperty(ws, 'url', {
-        value: '',
-        writable: false
-    });
-    // @ts-expect-error not a WS/WebSocket method
-    ws.dispatchEvent = (evt) => {
-        if (evt.type === 'close') {
-            ws.emit('close');
-        }
-        if (evt.type === 'open') {
-            ws.emit('open');
-        }
-        if (evt.type === 'message') {
-            const m = evt;
-            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;
-}
-//# sourceMappingURL=utils.js.map

package/dist/src/utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,UAAU,WAAW,CAAE,EAAgB;IAC3C,MAAM,CAAC,cAAc,CAAC,EAAE,EAAE,KAAK,EAAE;QAC/B,KAAK,EAAE,EAAE;QACT,QAAQ,EAAE,KAAK;KAChB,CAAC,CAAA;IAEF,6CAA6C;IAC7C,EAAE,CAAC,aAAa,GAAG,CAAC,GAAU,EAAE,EAAE;QAChC,IAAI,GAAG,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;YACzB,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;QAClB,CAAC;QAED,IAAI,GAAG,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;YACxB,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;QACjB,CAAC;QAED,IAAI,GAAG,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;YAC3B,MAAM,CAAC,GAAG,GAAmB,CAAA;YAC7B,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,CAAA;QACzB,CAAC;QAED,IAAI,GAAG,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;YACzB,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,KAAK,CAAC,mBAAmB,CAAC,CAAC,CAAA;QAClD,CAAC;QACD,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,CAAA;IACxB,CAAC,CAAA;IAED,uCAAuC;IACvC,OAAO,EAAE,CAAA;AACX,CAAC"}

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

@@ -1,9 +0,0 @@
-import type { MultiaddrConnection } from '@libp2p/interface';
-import type { AbstractMultiaddrConnectionInit } from '@libp2p/utils';
-export interface WebSocketMultiaddrConnectionInit extends Omit<AbstractMultiaddrConnectionInit, 'name'> {
-    websocket: WebSocket;
-    maxBufferedAmount?: number;
-    bufferedAmountPollInterval?: number;
-}
-export declare function webSocketToMaConn(init: WebSocketMultiaddrConnectionInit): MultiaddrConnection;
-//# sourceMappingURL=websocket-to-conn.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"websocket-to-conn.d.ts","sourceRoot":"","sources":["../../src/websocket-to-conn.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAgB,mBAAmB,EAAE,MAAM,mBAAmB,CAAA;AAC1E,OAAO,KAAK,EAAE,+BAA+B,EAA6B,MAAM,eAAe,CAAA;AAK/F,MAAM,WAAW,gCAAiC,SAAQ,IAAI,CAAC,+BAA+B,EAAE,MAAM,CAAC;IACrG,SAAS,EAAE,SAAS,CAAA;IACpB,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,0BAA0B,CAAC,EAAE,MAAM,CAAA;CACpC;AA4FD,wBAAgB,iBAAiB,CAAE,IAAI,EAAE,gCAAgC,GAAG,mBAAmB,CAE9F"}

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

@@ -1,83 +0,0 @@
-import { AbstractMultiaddrConnection, repeatingTask } from '@libp2p/utils';
-import { Uint8ArrayList } from 'uint8arraylist';
-import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string';
-const DEFAULT_MAX_BUFFERED_AMOUNT = 1024 * 1024 * 4;
-const DEFAULT_BUFFERED_AMOUNT_POLL_INTERVAL = 10;
-class WebSocketMultiaddrConnection extends AbstractMultiaddrConnection {
-    websocket;
-    maxBufferedAmount;
-    checkBufferedAmountTask;
-    constructor(init) {
-        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;
-                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) {
-                this.log.error('error receiving data - %e', err);
-            }
-        });
-    }
-    sendData(data) {
-        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() {
-        this.websocket.close(1006); // abnormal closure
-    }
-    async sendClose(options) {
-        this.websocket.close();
-        options?.signal?.throwIfAborted();
-    }
-    sendPause() {
-        // read backpressure is not supported
-    }
-    sendResume() {
-        // read backpressure is not supported
-    }
-    checkBufferedAmount() {
-        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) {
-    return new WebSocketMultiaddrConnection(init);
-}
-//# sourceMappingURL=websocket-to-conn.js.map