@libp2p/circuit-relay-v2 3.2.24-6059227cb → 3.2.24-87bc8d4fb

package/src/transport/transport.ts

@@ -0,0 +1,380 @@
+import { DialError, InvalidMessageError, serviceCapabilities, serviceDependencies, start, stop, transportSymbol } from '@libp2p/interface'
+import { peerFilter } from '@libp2p/peer-collections'
+import { peerIdFromMultihash, peerIdFromString } from '@libp2p/peer-id'
+import { streamToMaConnection } from '@libp2p/utils/stream-to-ma-conn'
+import { multiaddr } from '@multiformats/multiaddr'
+import { Circuit } from '@multiformats/multiaddr-matcher'
+import { pbStream } from 'it-protobuf-stream'
+import { setMaxListeners } from 'main-event'
+import * as Digest from 'multiformats/hashes/digest'
+import { CustomProgressEvent } from 'progress-events'
+import { CIRCUIT_PROTO_CODE, DEFAULT_DISCOVERY_FILTER_ERROR_RATE, DEFAULT_DISCOVERY_FILTER_SIZE, MAX_CONNECTIONS, RELAY_V2_HOP_CODEC, RELAY_V2_STOP_CODEC } from '../constants.js'
+import { StopMessage, HopMessage, Status } from '../pb/index.js'
+import { CircuitListen, CircuitSearch, LimitTracker } from '../utils.js'
+import { RelayDiscovery } from './discovery.js'
+import { createListener } from './listener.js'
+import { ReservationStore } from './reservation-store.js'
+import type { CircuitRelayTransportComponents, CircuitRelayTransportInit } from './index.js'
+import type { Transport, CreateListenerOptions, Listener, Upgrader, ComponentLogger, Logger, Connection, Stream, ConnectionGater, PeerId, PeerStore, OutboundConnectionUpgradeEvents, DialTransportOptions, OpenConnectionProgressEvents, IncomingStreamData } from '@libp2p/interface'
+import type { AddressManager, ConnectionManager, Registrar, TransportManager } from '@libp2p/interface-internal'
+import type { Multiaddr } from '@multiformats/multiaddr'
+import type { ProgressEvent } from 'progress-events'
+
+const isValidStop = (request: StopMessage): request is Required<StopMessage> => {
+  if (request.peer == null) {
+    return false
+  }
+
+  try {
+    request.peer.addrs.forEach(multiaddr)
+  } catch {
+    return false
+  }
+
+  return true
+}
+
+const defaults = {
+  maxInboundStopStreams: MAX_CONNECTIONS,
+  maxOutboundStopStreams: MAX_CONNECTIONS,
+  stopTimeout: 30000
+}
+
+export type CircuitRelayDialEvents =
+  OutboundConnectionUpgradeEvents |
+  OpenConnectionProgressEvents |
+  ProgressEvent<'circuit-relay:open-connection'> |
+  ProgressEvent<'circuit-relay:reuse-connection'> |
+  ProgressEvent<'circuit-relay:open-hop-stream'> |
+  ProgressEvent<'circuit-relay:write-connect-message'> |
+  ProgressEvent<'circuit-relay:read-connect-response'>
+
+export class CircuitRelayTransport implements Transport<CircuitRelayDialEvents> {
+  private readonly discovery?: RelayDiscovery
+  private readonly registrar: Registrar
+  private readonly peerStore: PeerStore
+  private readonly connectionManager: ConnectionManager
+  private readonly transportManager: TransportManager
+  private readonly peerId: PeerId
+  private readonly upgrader: Upgrader
+  private readonly addressManager: AddressManager
+  private readonly connectionGater: ConnectionGater
+  public readonly reservationStore: ReservationStore
+  private readonly logger: ComponentLogger
+  private readonly maxInboundStopStreams: number
+  private readonly maxOutboundStopStreams?: number
+  private started: boolean
+  private readonly log: Logger
+  private shutdownController: AbortController
+
+  constructor (components: CircuitRelayTransportComponents, init: CircuitRelayTransportInit = {}) {
+    this.log = components.logger.forComponent('libp2p:circuit-relay:transport')
+    this.registrar = components.registrar
+    this.peerStore = components.peerStore
+    this.connectionManager = components.connectionManager
+    this.transportManager = components.transportManager
+    this.logger = components.logger
+    this.peerId = components.peerId
+    this.upgrader = components.upgrader
+    this.addressManager = components.addressManager
+    this.connectionGater = components.connectionGater
+    this.maxInboundStopStreams = init.maxInboundStopStreams ?? defaults.maxInboundStopStreams
+    this.maxOutboundStopStreams = init.maxOutboundStopStreams ?? defaults.maxOutboundStopStreams
+    this.shutdownController = new AbortController()
+
+    this.discovery = new RelayDiscovery(components, {
+      filter: init.discoveryFilter ?? peerFilter(DEFAULT_DISCOVERY_FILTER_SIZE, DEFAULT_DISCOVERY_FILTER_ERROR_RATE)
+    })
+    this.discovery.addEventListener('relay:discover', (evt) => {
+      this.reservationStore.addRelay(evt.detail, 'discovered')
+        .catch(err => {
+          if (err.name !== 'HadEnoughRelaysError' && err.name !== 'RelayQueueFullError') {
+            this.log.error('could not add discovered relay %p', evt.detail, err)
+          }
+        })
+    })
+    this.reservationStore = new ReservationStore(components, init)
+    this.reservationStore.addEventListener('relay:not-enough-relays', () => {
+      this.discovery?.startDiscovery()
+    })
+    this.reservationStore.addEventListener('relay:found-enough-relays', () => {
+      this.discovery?.stopDiscovery()
+    })
+
+    this.started = false
+  }
+
+  readonly [Symbol.toStringTag] = '@libp2p/circuit-relay-v2-transport'
+
+  readonly [serviceCapabilities]: string[] = [
+    '@libp2p/transport',
+    '@libp2p/circuit-relay-v2-transport'
+  ]
+
+  get [serviceDependencies] (): string[] {
+    // we only need identify if discovery is enabled
+    if (this.discovery != null) {
+      return [
+        '@libp2p/identify'
+      ]
+    }
+
+    return []
+  }
+
+  readonly [transportSymbol] = true
+
+  isStarted (): boolean {
+    return this.started
+  }
+
+  async start (): Promise<void> {
+    this.shutdownController = new AbortController()
+    setMaxListeners(Infinity, this.shutdownController.signal)
+
+    await this.registrar.handle(RELAY_V2_STOP_CODEC, (data) => {
+      const signal = this.upgrader.createInboundAbortSignal(this.shutdownController.signal)
+
+      void this.onStop(data, signal)
+        .catch(err => {
+          this.log.error('error while handling STOP protocol', err)
+          data.stream.abort(err)
+        })
+        .finally(() => {
+          signal.clear()
+        })
+    }, {
+      maxInboundStreams: this.maxInboundStopStreams,
+      maxOutboundStreams: this.maxOutboundStopStreams,
+      runOnLimitedConnection: true
+    })
+
+    await start(this.discovery, this.reservationStore)
+
+    this.started = true
+  }
+
+  async stop (): Promise<void> {
+    this.shutdownController.abort()
+    await stop(this.discovery, this.reservationStore)
+    await this.registrar.unhandle(RELAY_V2_STOP_CODEC)
+
+    this.started = false
+  }
+
+  /**
+   * Dial a peer over a relay
+   */
+  async dial (ma: Multiaddr, options: DialTransportOptions<CircuitRelayDialEvents>): Promise<Connection> {
+    if (ma.protoCodes().filter(code => code === CIRCUIT_PROTO_CODE).length !== 1) {
+      const errMsg = 'Invalid circuit relay address'
+      this.log.error(errMsg, ma)
+      throw new DialError(errMsg)
+    }
+
+    // Check the multiaddr to see if it contains a relay and a destination peer
+    const addrs = ma.toString().split('/p2p-circuit')
+    const relayAddr = multiaddr(addrs[0])
+    const destinationAddr = multiaddr(addrs[addrs.length - 1])
+    const relayId = relayAddr.getPeerId()
+    const destinationId = destinationAddr.getPeerId()
+
+    if (relayId == null || destinationId == null) {
+      const errMsg = `ircuit relay dial to ${ma.toString()} failed as address did not have both relay and destination PeerIDs`
+      this.log.error(`c${errMsg}`)
+      throw new DialError(`C${errMsg}`)
+    }
+
+    const relayPeer = peerIdFromString(relayId)
+    const destinationPeer = peerIdFromString(destinationId)
+
+    const relayConnections = this.connectionManager.getConnections(relayPeer)
+    let relayConnection = relayConnections[0]
+
+    if (relayConnection == null) {
+      await this.peerStore.merge(relayPeer, {
+        multiaddrs: [relayAddr]
+      })
+
+      options.onProgress?.(new CustomProgressEvent('circuit-relay:open-connection'))
+      relayConnection = await this.connectionManager.openConnection(relayPeer, options)
+    } else {
+      options.onProgress?.(new CustomProgressEvent('circuit-relay:reuse-connection'))
+    }
+
+    let stream: Stream | undefined
+
+    try {
+      options.onProgress?.(new CustomProgressEvent('circuit-relay:open-hop-stream'))
+      stream = await relayConnection.newStream(RELAY_V2_HOP_CODEC, options)
+
+      const pbstr = pbStream(stream)
+      const hopstr = pbstr.pb(HopMessage)
+
+      options.onProgress?.(new CustomProgressEvent('circuit-relay:write-connect-message'))
+      await hopstr.write({
+        type: HopMessage.Type.CONNECT,
+        peer: {
+          id: destinationPeer.toMultihash().bytes,
+          addrs: [multiaddr(destinationAddr).bytes]
+        }
+      }, options)
+
+      options.onProgress?.(new CustomProgressEvent('circuit-relay:read-connect-response'))
+      const status = await hopstr.read(options)
+
+      if (status.status !== Status.OK) {
+        throw new InvalidMessageError(`failed to connect via relay with status ${status?.status?.toString() ?? 'undefined'}`)
+      }
+
+      const limits = new LimitTracker(status.limit)
+
+      const maConn = streamToMaConnection({
+        stream: pbstr.unwrap(),
+        remoteAddr: ma,
+        localAddr: relayAddr.encapsulate(`/p2p-circuit/p2p/${this.peerId.toString()}`),
+        log: this.log,
+        onDataRead: limits.onData,
+        onDataWrite: limits.onData
+      })
+
+      const conn = await this.upgrader.upgradeOutbound(maConn, {
+        ...options,
+        limits: limits.getLimits()
+      })
+
+      conn.log('outbound relayed connection established to %p with limits %o, over connection %s', conn.remotePeer, status.limit ?? 'none', relayConnection.id)
+
+      return conn
+    } catch (err: any) {
+      this.log.error('circuit relay dial to destination %p via relay %p failed', destinationPeer, relayPeer, err)
+      stream?.abort(err)
+
+      throw err
+    }
+  }
+
+  /**
+   * Create a listener
+   */
+  createListener (options: CreateListenerOptions): Listener {
+    return createListener({
+      peerId: this.peerId,
+      connectionManager: this.connectionManager,
+      addressManager: this.addressManager,
+      reservationStore: this.reservationStore,
+      logger: this.logger
+    })
+  }
+
+  /**
+   * Filter check for all Multiaddrs that this transport can listen on
+   */
+  listenFilter (multiaddrs: Multiaddr[]): Multiaddr[] {
+    multiaddrs = Array.isArray(multiaddrs) ? multiaddrs : [multiaddrs]
+
+    return multiaddrs.filter((ma) => {
+      return CircuitListen.exactMatch(ma) || CircuitSearch.exactMatch(ma)
+    })
+  }
+
+  /**
+   * Filter check for all Multiaddrs that this transport can dial
+   */
+  dialFilter (multiaddrs: Multiaddr[]): Multiaddr[] {
+    multiaddrs = Array.isArray(multiaddrs) ? multiaddrs : [multiaddrs]
+
+    return multiaddrs.filter((ma) => {
+      return Circuit.exactMatch(ma)
+    })
+  }
+
+  /**
+   * An incoming STOP request means a remote peer wants to dial us via a relay
+   */
+  async onStop ({ connection, stream }: IncomingStreamData, signal: AbortSignal): Promise<void> {
+    if (!this.reservationStore.hasReservation(connection.remotePeer)) {
+      try {
+        this.log('dialed via relay we did not have a reservation on, start listening on that relay address')
+        await this.transportManager.listen([connection.remoteAddr.encapsulate('/p2p-circuit')])
+      } catch (err: any) {
+        // failed to refresh our hitherto unknown relay reservation but allow the connection attempt anyway
+        this.log.error('failed to listen on a relay peer we were dialed via but did not have a reservation on', err)
+      }
+    }
+
+    const pbstr = pbStream(stream).pb(StopMessage)
+    const request = await pbstr.read({
+      signal
+    })
+
+    this.log('new circuit relay v2 stop stream from %p with type %s', connection.remotePeer, request.type)
+
+    if (request?.type === undefined) {
+      this.log.error('type was missing from circuit v2 stop protocol request from %s', connection.remotePeer)
+      await pbstr.write({ type: StopMessage.Type.STATUS, status: Status.MALFORMED_MESSAGE }, {
+        signal
+      })
+      await stream.close()
+      return
+    }
+
+    // Validate the STOP request has the required input
+    if (request.type !== StopMessage.Type.CONNECT) {
+      this.log.error('invalid stop connect request via peer %p', connection.remotePeer)
+      await pbstr.write({ type: StopMessage.Type.STATUS, status: Status.UNEXPECTED_MESSAGE }, {
+        signal
+      })
+      await stream.close()
+      return
+    }
+
+    if (!isValidStop(request)) {
+      this.log.error('invalid stop connect request via peer %p', connection.remotePeer)
+      await pbstr.write({ type: StopMessage.Type.STATUS, status: Status.MALFORMED_MESSAGE }, {
+        signal
+      })
+      await stream.close({
+        signal
+      })
+      return
+    }
+
+    const remotePeerId = peerIdFromMultihash(Digest.decode(request.peer.id))
+
+    if ((await this.connectionGater.denyInboundRelayedConnection?.(connection.remotePeer, remotePeerId)) === true) {
+      this.log.error('connection gater denied inbound relayed connection from %p', connection.remotePeer)
+      await pbstr.write({ type: StopMessage.Type.STATUS, status: Status.PERMISSION_DENIED }, {
+        signal
+      })
+      await stream.close({
+        signal
+      })
+      return
+    }
+
+    this.log.trace('sending success response to %p', connection.remotePeer)
+    await pbstr.write({ type: StopMessage.Type.STATUS, status: Status.OK }, {
+      signal
+    })
+
+    const limits = new LimitTracker(request.limit)
+    const remoteAddr = connection.remoteAddr.encapsulate(`/p2p-circuit/p2p/${remotePeerId.toString()}`)
+    const localAddr = this.addressManager.getAddresses()[0]
+    const maConn = streamToMaConnection({
+      stream: pbstr.unwrap().unwrap(),
+      remoteAddr,
+      localAddr,
+      log: this.log,
+      onDataRead: limits.onData,
+      onDataWrite: limits.onData
+    })
+
+    await this.upgrader.upgradeInbound(maConn, {
+      limits: limits.getLimits(),
+      signal
+    })
+
+    maConn.log('inbound relayed connection established to %p with limits %o, over connection %s', remotePeerId, request.limit ?? 'none', connection.id)
+  }
+}

package/src/utils.ts

@@ -1,5 +1,3 @@
-import { setMaxListeners } from '@libp2p/interface'
-import { pipe } from '@libp2p/utils'
 import { CODE_P2P_CIRCUIT } from '@multiformats/multiaddr'
 import { P2P } from '@multiformats/multiaddr-matcher'
 import { fmt, code, and } from '@multiformats/multiaddr-matcher/utils'
@@ -9,21 +7,35 @@ import { sha256 } from 'multiformats/hashes/sha2'
 import { DurationLimitError, TransferLimitError } from './errors.js'
 import type { RelayReservation } from './index.js'
 import type { Limit } from './pb/index.js'
-import type { ConnectionLimits, LoggerOptions, Stream, MessageStream, StreamMessageEvent } from '@libp2p/interface'
+import type { ConnectionLimits, LoggerOptions, Stream } from '@libp2p/interface'
+import type { Source } from 'it-stream-types'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
-function countStreamBytes (source: MessageStream, limit: { remaining: bigint }, options: LoggerOptions): void {
+async function * countStreamBytes (source: Source<Uint8Array | Uint8ArrayList>, limit: { remaining: bigint }, options: LoggerOptions): AsyncGenerator<Uint8Array | Uint8ArrayList, void, unknown> {
   const limitBytes = limit.remaining
 
-  const abortIfStreamByteLimitExceeded = (evt: StreamMessageEvent): void => {
-    const len = BigInt(evt.data.byteLength)
-    limit.remaining -= len
+  for await (const buf of source) {
+    const len = BigInt(buf.byteLength)
+
+    if ((limit.remaining - len) < 0) {
+      // this is a safe downcast since len is guarantee to be in the range for a number
+      const remaining = Number(limit.remaining)
+      limit.remaining = 0n
 
-    if (limit.remaining < 0) {
-      source.abort(new TransferLimitError(`data limit of ${limitBytes} bytes exceeded`))
+      try {
+        if (remaining !== 0) {
+          yield buf.subarray(0, remaining)
+        }
+      } catch (err: any) {
+        options.log.error(err)
+      }
+
+      throw new TransferLimitError(`data limit of ${limitBytes} bytes exceeded`)
     }
+
+    limit.remaining -= len
+    yield buf
   }
-  source.addEventListener('message', abortIfStreamByteLimitExceeded)
 }
 
 export function createLimitedRelay (src: Stream, dst: Stream, abortSignal: AbortSignal, reservation: RelayReservation, options: LoggerOptions): void {
@@ -37,13 +49,13 @@ export function createLimitedRelay (src: Stream, dst: Stream, abortSignal: Abort
 
   if (reservation.limit?.duration != null) {
     options.log('limiting relayed connection duration to %dms', reservation.limit.duration)
-    const durationSignal = AbortSignal.timeout(reservation.limit.duration)
-    setMaxListeners(Infinity, durationSignal)
-    signals.push(durationSignal)
+    signals.push(AbortSignal.timeout(reservation.limit.duration))
   }
 
   const signal = anySignal(signals)
-  setMaxListeners(Infinity, signal)
+
+  let srcDstFinished = false
+  let dstSrcFinished = false
 
   let dataLimit: { remaining: bigint } | undefined
 
@@ -53,34 +65,51 @@ export function createLimitedRelay (src: Stream, dst: Stream, abortSignal: Abort
     }
   }
 
-  const onAbort = (): void => {
-    let err: Error
+  queueMicrotask(() => {
+    const onAbort = (): void => {
+      options.log('relayed connection reached time limit')
+      dst.abort(new DurationLimitError(`duration limit of ${reservation.limit?.duration} ms exceeded`))
+    }
 
-    if (abortSignal.aborted) {
-      err = abortSignal.reason
-    } else {
-      err = new DurationLimitError(`duration limit of ${reservation.limit?.duration} ms exceeded`)
+    signal.addEventListener('abort', onAbort, { once: true })
+
+    void dst.sink(dataLimit == null ? src.source : countStreamBytes(src.source, dataLimit, options))
+      .catch(err => {
+        options.log.error('error while relaying streams src -> dst', err)
+        abortStreams(err)
+      })
+      .finally(() => {
+        srcDstFinished = true
+
+        if (dstSrcFinished) {
+          signal.removeEventListener('abort', onAbort)
+          signal.clear()
+        }
+      })
+  })
+
+  queueMicrotask(() => {
+    const onAbort = (): void => {
+      options.log('relayed connection reached time limit')
+      src.abort(new DurationLimitError(`duration limit of ${reservation.limit?.duration} ms exceeded`))
     }
 
-    abortStreams(err)
-  }
-  signal.addEventListener('abort', onAbort, { once: true })
+    signal.addEventListener('abort', onAbort, { once: true })
 
-  if (dataLimit != null) {
-    countStreamBytes(dst, dataLimit, options)
-    countStreamBytes(src, dataLimit, options)
-  }
+    void src.sink(dataLimit == null ? dst.source : countStreamBytes(dst.source, dataLimit, options))
+      .catch(err => {
+        options.log.error('error while relaying streams dst -> src', err)
+        abortStreams(err)
+      })
+      .finally(() => {
+        dstSrcFinished = true
 
-  // join the streams together
-  pipe(
-    src, dst, src
-  )
-    .catch(err => {
-      abortStreams(err)
-    })
-    .finally(() => {
-      signal.clear()
-    })
+        if (srcDstFinished) {
+          signal.removeEventListener('abort', onAbort)
+          signal.clear()
+        }
+      })
+  })
 }
 
 /**

package/dist/src/transport/stream-to-conn.d.ts

@@ -1,19 +0,0 @@
-import { Uint8ArrayList } from 'uint8arraylist';
-import type { MultiaddrConnection, Stream } from '@libp2p/interface';
-import type { AbstractMultiaddrConnectionInit } from '@libp2p/utils';
-export interface StreamMultiaddrConnectionInit extends Omit<AbstractMultiaddrConnectionInit, 'direction'> {
-    stream: Stream;
-    /**
-     * A callback invoked when data is read from the stream
-     */
-    onDataRead?(buf: Uint8ArrayList | Uint8Array): void;
-    /**
-     * A callback invoked when data is written to the stream
-     */
-    onDataWrite?(buf: Uint8ArrayList | Uint8Array): void;
-}
-/**
- * Convert a Stream into a MultiaddrConnection.
- */
-export declare function streamToMaConnection(init: StreamMultiaddrConnectionInit): MultiaddrConnection;
-//# sourceMappingURL=stream-to-conn.d.ts.map

package/dist/src/transport/stream-to-conn.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stream-to-conn.d.ts","sourceRoot":"","sources":["../../../src/transport/stream-to-conn.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAC/C,OAAO,KAAK,EAAgB,mBAAmB,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAClF,OAAO,KAAK,EAAE,+BAA+B,EAAc,MAAM,eAAe,CAAA;AAEhF,MAAM,WAAW,6BAA8B,SAAQ,IAAI,CAAC,+BAA+B,EAAE,WAAW,CAAC;IACvG,MAAM,EAAE,MAAM,CAAA;IAEd;;OAEG;IACH,UAAU,CAAC,CAAC,GAAG,EAAE,cAAc,GAAG,UAAU,GAAG,IAAI,CAAA;IAEnD;;OAEG;IACH,WAAW,CAAC,CAAC,GAAG,EAAE,cAAc,GAAG,UAAU,GAAG,IAAI,CAAA;CACrD;AAoED;;GAEG;AACH,wBAAgB,oBAAoB,CAAE,IAAI,EAAE,6BAA6B,GAAG,mBAAmB,CAE9F"}

package/dist/src/transport/stream-to-conn.js

@@ -1,60 +0,0 @@
-import { AbstractMultiaddrConnection } from '@libp2p/utils';
-import { Uint8ArrayList } from 'uint8arraylist';
-class StreamMultiaddrConnection extends AbstractMultiaddrConnection {
-    stream;
-    init;
-    constructor(init) {
-        super({
-            ...init,
-            direction: init.stream.direction
-        });
-        this.init = init;
-        this.stream = init.stream;
-        this.stream.addEventListener('close', (evt) => {
-            this.onTransportClosed(evt.error);
-        });
-        this.stream.addEventListener('remoteCloseWrite', (evt) => {
-            this.onRemoteCloseWrite();
-            // close our end when the remote closes
-            this.close()
-                .catch(err => {
-                this.abort(err);
-            });
-        });
-        // count incoming bytes
-        this.stream.addEventListener('message', (evt) => {
-            init.onDataRead?.(evt.data);
-            this.onData(evt.data);
-        });
-        // forward drain events
-        this.stream.addEventListener('drain', () => {
-            this.safeDispatchEvent('drain');
-        });
-    }
-    sendData(data) {
-        this.init.onDataWrite?.(data);
-        return {
-            sentBytes: data.byteLength,
-            canSendMore: this.stream.send(data)
-        };
-    }
-    async sendClose(options) {
-        await this.stream.close(options);
-    }
-    sendReset() {
-        this.stream.abort(new Error('An error occurred'));
-    }
-    sendPause() {
-        this.stream.pause();
-    }
-    sendResume() {
-        this.stream.resume();
-    }
-}
-/**
- * Convert a Stream into a MultiaddrConnection.
- */
-export function streamToMaConnection(init) {
-    return new StreamMultiaddrConnection(init);
-}
-//# sourceMappingURL=stream-to-conn.js.map

package/dist/src/transport/stream-to-conn.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"stream-to-conn.js","sourceRoot":"","sources":["../../../src/transport/stream-to-conn.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,eAAe,CAAA;AAC3D,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAkB/C,MAAM,yBAA0B,SAAQ,2BAA2B;IACzD,MAAM,CAAQ;IACd,IAAI,CAA+B;IAE3C,YAAa,IAAmC;QAC9C,KAAK,CAAC;YACJ,GAAG,IAAI;YACP,SAAS,EAAE,IAAI,CAAC,MAAM,CAAC,SAAS;SAEjC,CAAC,CAAA;QAEF,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;QAChB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAA;QAEzB,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,EAAE;YAC5C,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,KAAK,CAAC,CAAA;QACnC,CAAC,CAAC,CAAA;QAEF,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC,kBAAkB,EAAE,CAAC,GAAG,EAAE,EAAE;YACvD,IAAI,CAAC,kBAAkB,EAAE,CAAA;YAEzB,uCAAuC;YACvC,IAAI,CAAC,KAAK,EAAE;iBACT,KAAK,CAAC,GAAG,CAAC,EAAE;gBACX,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;YACjB,CAAC,CAAC,CAAA;QACN,CAAC,CAAC,CAAA;QAEF,uBAAuB;QACvB,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC,SAAS,EAAE,CAAC,GAAG,EAAE,EAAE;YAC9C,IAAI,CAAC,UAAU,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;YAC3B,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;QACvB,CAAC,CAAC,CAAA;QAEF,uBAAuB;QACvB,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,GAAG,EAAE;YACzC,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAA;QACjC,CAAC,CAAC,CAAA;IACJ,CAAC;IAED,QAAQ,CAAE,IAAoB;QAC5B,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,IAAI,CAAC,CAAA;QAE7B,OAAO;YACL,SAAS,EAAE,IAAI,CAAC,UAAU;YAC1B,WAAW,EAAE,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC;SACpC,CAAA;IACH,CAAC;IAED,KAAK,CAAC,SAAS,CAAE,OAAsB;QACrC,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;IAClC,CAAC;IAED,SAAS;QACP,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,mBAAmB,CAAC,CAAC,CAAA;IACnD,CAAC;IAED,SAAS;QACP,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAA;IACrB,CAAC;IAED,UAAU;QACR,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAA;IACtB,CAAC;CACF;AAED;;GAEG;AACH,MAAM,UAAU,oBAAoB,CAAE,IAAmC;IACvE,OAAO,IAAI,yBAAyB,CAAC,IAAI,CAAC,CAAA;AAC5C,CAAC"}