@libp2p/utils 6.7.2-8484de8a2 → 6.7.2-87bc8d4fb

package/src/mock-muxer.ts

@@ -1,304 +0,0 @@
-import * as cborg from 'cborg'
-import * as lp from 'it-length-prefixed'
-import { pushable } from 'it-pushable'
-import { Uint8ArrayList } from 'uint8arraylist'
-import { AbstractStreamMuxer } from './abstract-stream-muxer.ts'
-import { AbstractStream } from './abstract-stream.ts'
-import { Queue } from './queue/index.js'
-import type { SendResult } from './abstract-message-stream.ts'
-import type { AbstractStreamInit } from './abstract-stream.ts'
-import type { AbortOptions, MessageStreamDirection, CreateStreamOptions, StreamMuxerFactory, StreamMuxer, MultiaddrConnection, StreamMuxerOptions } from '@libp2p/interface'
-import type { Pushable } from 'it-pushable'
-import type { SupportedEncodings } from 'uint8arrays/from-string'
-
-interface DataMessage {
-  id: string
-  type: 'data'
-  chunk: Uint8Array
-}
-
-interface ResetMessage {
-  id: string
-  type: 'reset'
-}
-
-interface CloseWriteMessage {
-  id: string
-  type: 'closeWrite'
-}
-
-interface CloseReadMessage {
-  id: string
-  type: 'closeRead'
-}
-
-interface CreateMessage {
-  id: string
-  type: 'create'
-  protocol?: string
-}
-
-interface PauseMessage {
-  id: string
-  type: 'pause'
-}
-
-interface ResumeMessage {
-  id: string
-  type: 'resume'
-}
-
-type StreamMessage = DataMessage | ResetMessage | CloseWriteMessage | CloseReadMessage | CreateMessage | PauseMessage | ResumeMessage
-
-export interface MockMuxedStreamInit extends AbstractStreamInit {
-  sendMessage(message: StreamMessage): boolean
-  encoding: SupportedEncodings
-}
-
-class MockMuxedStream extends AbstractStream {
-  private readonly sendMessage: (message: StreamMessage) => boolean
-  private dataQueue: Queue
-  private encoding: SupportedEncodings
-
-  constructor (init: MockMuxedStreamInit) {
-    super(init)
-
-    this.sendMessage = init.sendMessage
-    this.encoding = init.encoding
-    this.dataQueue = new Queue({
-      concurrency: 1
-    })
-
-    if (this.direction === 'outbound') {
-      this.sendMessage({
-        id: this.id,
-        type: 'create',
-        protocol: this.protocol
-      })
-    }
-  }
-
-  sendData (data: Uint8ArrayList): SendResult {
-    const canSendMore = this.sendMessage({
-      id: this.id,
-      type: 'data',
-      chunk: data.subarray()
-    })
-
-    return {
-      sentBytes: data.byteLength,
-      canSendMore
-    }
-  }
-
-  sendReset (): void {
-    this.sendMessage({
-      id: this.id,
-      type: 'reset'
-    })
-  }
-
-  async sendCloseWrite (options?: AbortOptions): Promise<void> {
-    this.sendMessage({
-      id: this.id,
-      type: 'closeWrite'
-    })
-
-    options?.signal?.throwIfAborted()
-  }
-
-  async sendCloseRead (options?: AbortOptions): Promise<void> {
-    this.sendMessage({
-      id: this.id,
-      type: 'closeRead'
-    })
-
-    options?.signal?.throwIfAborted()
-  }
-
-  sendPause (): void {
-    this.sendMessage({
-      id: this.id,
-      type: 'pause'
-    })
-  }
-
-  sendResume (): void {
-    this.sendMessage({
-      id: this.id,
-      type: 'resume'
-    })
-  }
-
-  onRemotePaused (): void {
-    this.dataQueue.pause()
-  }
-
-  onRemoteResumed (): void {
-    this.dataQueue.resume()
-  }
-}
-
-interface MockMuxerInit extends StreamMuxerOptions {
-  /**
-   * How long the input queue can grow
-   */
-  maxInputQueueSize?: number
-
-  /**
-   * How to encode data message
-   *
-   * @default base64
-   */
-  encoding?: SupportedEncodings
-
-  /**
-   * How large muxer messages are allowed to be
-   */
-  maxMessageSize?: number
-}
-
-// CBOR encoding of non-message data fields
-const MESSAGE_OVERHEAD = 30
-
-class MockMuxer extends AbstractStreamMuxer<MockMuxedStream> {
-  private input: Pushable<Uint8Array | Uint8ArrayList>
-  private maxInputQueueSize: number
-  private encoding: SupportedEncodings
-  private maxMessageSize: number
-  private nextStreamId: number
-
-  constructor (maConn: MultiaddrConnection, init: MockMuxerInit) {
-    super(maConn, {
-      ...init,
-      protocol: '/mock-muxer/1.0.0',
-      name: 'mock-muxer'
-    })
-
-    this.maxInputQueueSize = init.maxInputQueueSize ?? 1024 * 1024 * 10
-    this.maxMessageSize = (init.maxMessageSize ?? 1024 * 1024 * 4) + MESSAGE_OVERHEAD
-    this.encoding = init.encoding ?? 'base64'
-    this.input = pushable()
-    this.sendMessage = this.sendMessage.bind(this)
-    this.nextStreamId = this.maConn.direction === 'outbound' ? 0 : 1
-
-    Promise.resolve()
-      .then(async () => {
-        for await (const buf of lp.decode(this.input, {
-          maxDataLength: this.maxMessageSize
-        })) {
-          this.onMessage(cborg.decode(buf.subarray()))
-        }
-      })
-      .catch(err => {
-        this.abort(err)
-      })
-  }
-
-  onData (data: Uint8Array | Uint8ArrayList): void {
-    if (this.input.readableLength >= this.maxInputQueueSize) {
-      this.abort(new Error(`Input queue exceeded maximum size ${this.input.readableLength} >= ${this.maxInputQueueSize}`))
-      return
-    }
-
-    this.input.push(data)
-  }
-
-  sendMessage (message: StreamMessage): boolean {
-    if (message.type === 'data') {
-      this.log.trace('send message %o', { ...message, chunk: `[ ${message.chunk.byteLength} bytes ]` })
-    } else {
-      this.log.trace('send message %o', message)
-    }
-
-    const buf = cborg.encode(message)
-    const encoded = lp.encode.single(buf, {
-      maxDataLength: this.maxMessageSize
-    })
-
-    return this.send(encoded)
-  }
-
-  onMessage (message: StreamMessage): void {
-    if (message.type === 'data') {
-      this.log.trace('incoming message %o', { ...message, chunk: `[ ${message.chunk.byteLength} bytes ]` })
-    } else {
-      this.log.trace('incoming message %o', message)
-    }
-
-    let stream: MockMuxedStream | undefined = this.streams.find(s => s.id === message.id)
-
-    if (message.type === 'create') {
-      if (stream != null) {
-        throw new Error(`Already had stream for ${message.id}`)
-      }
-
-      this.log.trace('create stream inbound %s', message.id)
-      stream = this._createStream(message.id, 'inbound', {
-        protocol: message.protocol
-      })
-
-      this.onRemoteStream(stream)
-    }
-
-    if (stream == null) {
-      this.log.error(`No stream found for ${message.id}`)
-      return
-    }
-
-    if (message.type === 'data') {
-      stream.onData(message.chunk)
-    } else if (message.type === 'reset') {
-      stream.onRemoteReset()
-    } else if (message.type === 'closeWrite') {
-      stream.onRemoteCloseWrite()
-    } else if (message.type === 'closeRead') {
-      stream.onRemoteCloseRead()
-    } else if (message.type === 'pause') {
-      stream.onRemotePaused()
-    } else if (message.type === 'resume') {
-      stream.onRemoteResumed()
-    }
-  }
-
-  onCreateStream (options: CreateStreamOptions): MockMuxedStream {
-    this.nextStreamId += 2
-
-    return this._createStream(`${this.nextStreamId}`, 'outbound', options)
-  }
-
-  _createStream (id: string, direction: MessageStreamDirection, options: CreateStreamOptions): MockMuxedStream {
-    this.log.trace('createStream %s %s', direction, id)
-
-    return new MockMuxedStream({
-      ...this.streamOptions,
-      ...options,
-      id,
-      direction,
-      log: this.log.newScope(`stream:${direction}:${id}`),
-      sendMessage: this.sendMessage,
-      encoding: this.encoding,
-      maxMessageSize: this.maxMessageSize - MESSAGE_OVERHEAD,
-      protocol: ''
-    })
-  }
-}
-
-class MockMuxerFactory implements StreamMuxerFactory {
-  public protocol: string = '/mock-muxer/1.0.0'
-  private init: MockMuxerInit
-
-  constructor (init: MockMuxerInit) {
-    this.init = init
-  }
-
-  createStreamMuxer (maConn: MultiaddrConnection): StreamMuxer {
-    return new MockMuxer(maConn, {
-      ...this.init
-    })
-  }
-}
-
-export function mockMuxer (init: MockMuxerInit = {}): StreamMuxerFactory {
-  return new MockMuxerFactory(init)
-}

package/src/mock-stream.ts

@@ -1,101 +0,0 @@
-import { StreamMessageEvent } from '@libp2p/interface'
-import { defaultLogger } from '@libp2p/logger'
-import { raceSignal } from 'race-signal'
-import { AbstractStream } from './abstract-stream.ts'
-import type { SendResult } from './abstract-message-stream.ts'
-import type { MessageQueue, MessageQueueEvents } from './message-queue.ts'
-import type { AbortOptions, MessageStreamDirection, TypedEventTarget } from '@libp2p/interface'
-import type { Uint8ArrayList } from 'uint8arraylist'
-
-interface MockStreamMessages extends MessageQueueEvents {
-  closeWrite: Event
-  closeRead: Event
-}
-
-interface MockStreamInit {
-  delay?: number
-  direction: MessageStreamDirection
-  local: MessageQueue<MockStreamMessages>
-  remote: TypedEventTarget<MockStreamMessages>
-}
-
-let streamId = 0
-
-export class MockStream extends AbstractStream {
-  private local: MessageQueue<MockStreamMessages>
-  private remote: TypedEventTarget<MockStreamMessages>
-
-  constructor (init: MockStreamInit) {
-    const id = `${streamId++}`
-
-    super({
-      ...init,
-      id,
-      log: defaultLogger().forComponent(`libp2p:stream-pair:${init.direction}:${id}`)
-    })
-
-    this.local = init.local
-    this.remote = init.remote
-
-    this.local.addEventListener('drain', () => {
-      this.safeDispatchEvent('drain')
-    })
-
-    this.remote.addEventListener('message', (evt) => {
-      this.onData(evt.data)
-    })
-    this.remote.addEventListener('reset', (evt) => {
-      this.onRemoteReset()
-    })
-    this.remote.addEventListener('closeWrite', (evt) => {
-      this.onRemoteCloseWrite()
-    })
-  }
-
-  sendData (data: Uint8ArrayList): SendResult {
-    const canSendMore = this.local.send(new StreamMessageEvent(data))
-
-    return {
-      sentBytes: data.byteLength,
-      canSendMore
-    }
-  }
-
-  sendReset (): void {
-    this.local.send(new Event('reset'))
-  }
-
-  async sendCloseWrite (options?: AbortOptions): Promise<void> {
-    return raceSignal(new Promise<void>((resolve, reject) => {
-      this.local.send(new Event('closeWrite'))
-      this.local.onIdle().then(resolve, reject)
-    }), options?.signal)
-  }
-
-  async sendCloseRead (options?: AbortOptions): Promise<void> {
-    return raceSignal(new Promise<void>((resolve, reject) => {
-      this.local.send(new Event('closeRead'))
-      this.local.onIdle().then(resolve, reject)
-    }), options?.signal)
-  }
-
-  sendPause (): void {
-    this.local.send(new Event('pause'))
-  }
-
-  sendResume (): void {
-    this.local.send(new Event('resume'))
-  }
-
-  onRemotePaused (): void {
-    this.local.pause()
-  }
-
-  onRemoteResumed (): void {
-    this.local.resume()
-  }
-
-  onMuxerDrain (): void {
-    this.local.resume()
-  }
-}

package/src/multiaddr/get-net-config.ts

@@ -1,112 +0,0 @@
-import { InvalidParametersError } from '@libp2p/interface'
-import type { Multiaddr } from '@multiformats/multiaddr'
-
-export interface IP4NetConfig {
-  type: 'ip4'
-  host: string
-  protocol?: 'tcp' | 'udp'
-  port?: number
-  cidr?: number
-  sni?: string
-}
-
-export interface IP6NetConfig {
-  type: 'ip6'
-  host: string
-  protocol?: 'tcp' | 'udp'
-  port?: number
-  zone?: string
-  cidr?: string
-  sni?: string
-}
-
-export interface DNSNetConfig {
-  type: 'dns'
-  host: string
-  protocol?: 'tcp' | 'udp'
-  port: number
-  cidr?: number
-}
-
-export interface DNS4NetConfig {
-  type: 'dns4'
-  host: string
-  protocol?: 'tcp' | 'udp'
-  port: number
-  cidr?: number
-}
-
-export interface DNS6NetConfig {
-  type: 'dns6'
-  host: string
-  protocol?: 'tcp' | 'udp'
-  port: number
-  cidr?: number
-}
-
-export interface DNSAddrNetConfig {
-  type: 'dnsaddr'
-  host: string
-  protocol?: 'tcp' | 'udp'
-  port: number
-  cidr?: number
-}
-
-export type NetConfig = IP4NetConfig | IP6NetConfig | DNSNetConfig | DNS4NetConfig | DNS6NetConfig | DNSAddrNetConfig
-
-/**
- * Returns host/port/etc information for multiaddrs, if it is available.
- *
- * It will throw if the passed multiaddr does not start with a network address,
- * e.g. a IPv4, IPv6, DNS, DNS4, DNS6 or DNSADDR address
- */
-export function getNetConfig (ma: Multiaddr): NetConfig {
-  const components = ma.getComponents()
-  const config: any = {}
-  let index = 0
-
-  if (components[index]?.name === 'ip6zone') {
-    config.zone = `${components[index].value}`
-    index++
-  }
-
-  if (components[index].name === 'ip4' || components[index].name === 'ip6') {
-    config.type = components[index].name
-    config.host = components[index].value
-    index++
-  } else if (components[index].name === 'dns' || components[index].name === 'dns4' || components[index].name === 'dns6') {
-    config.type = components[index].name
-    config.host = components[index].value
-    index++
-  } else if (components[index].name === 'dnsaddr') {
-    config.type = components[index].name
-    config.host = `_dnsaddr.${components[index].value}`
-    index++
-  }
-
-  if (components[index]?.name === 'tcp' || components[index]?.name === 'udp') {
-    config.protocol = components[index].name === 'tcp' ? 'tcp' : 'udp'
-    config.port = parseInt(`${components[index].value}`)
-    index++
-  }
-
-  if (components[index]?.name === 'ipcidr') {
-    if (config.type === 'ip4') {
-      config.cidr = parseInt(`${components[index].value}`)
-    } else if (config.type === 'ip6') {
-      config.cidr = `${components[index].value}`
-    }
-    index++
-  }
-
-  if (config.type == null || config.host == null) {
-    throw new InvalidParametersError(`Multiaddr ${ma} was not an IPv4, IPv6, DNS, DNS4, DNS6 or DNSADDR address`)
-  }
-
-  if (components[index]?.name === 'tls' && components[index + 1]?.name === 'sni') {
-    config.sni = components[index + 1].value
-    index += 2
-  }
-
-  return config
-}

package/src/multiaddr/index.ts

@@ -1,6 +0,0 @@
-export * from './get-net-config.ts'
-export * from './is-global-unicast.js'
-export * from './is-link-local.js'
-export * from './is-loopback.js'
-export * from './is-network-address.js'
-export * from './is-private.js'

package/src/multiaddr/utils.ts

@@ -1,46 +0,0 @@
-import { CODE_IP4, CODE_IP6, CODE_IP6ZONE, multiaddr } from '@multiformats/multiaddr'
-import type { NetConfig } from './get-net-config.ts'
-import type { Multiaddr } from '@multiformats/multiaddr'
-
-export function getIpFromMultiaddr (ma: Multiaddr): string | undefined {
-  const components = ma.getComponents()
-  let index = 0
-
-  if (components[0]?.code === CODE_IP6ZONE) {
-    index++
-  }
-
-  if (components[index]?.code !== CODE_IP4 && components[index]?.code !== CODE_IP6) {
-    return
-  }
-
-  return components[index]?.value
-}
-
-export function netConfigToMultiaddr (config: NetConfig, port?: number | string, host?: string): Multiaddr {
-  const parts: Array<string | number> = [
-    config.type,
-    host ?? config.host
-  ]
-
-  if (config.protocol != null) {
-    const p = port ?? config.port
-
-    if (p != null) {
-      parts.push(
-        config.protocol,
-        p
-      )
-    }
-  }
-
-  if (config.type === 'ip6' && config.zone != null) {
-    parts.unshift('ip6zone', config.zone)
-  }
-
-  if (config.cidr != null) {
-    parts.push('ipcidr', config.cidr)
-  }
-
-  return multiaddr(`/${parts.join('/')}`)
-}

package/src/multiaddr-connection-pair.ts

@@ -1,147 +0,0 @@
-import { StreamMessageEvent } from '@libp2p/interface'
-import { defaultLogger } from '@libp2p/logger'
-import { multiaddr } from '@multiformats/multiaddr'
-import { pEvent } from 'p-event'
-import { raceSignal } from 'race-signal'
-import { AbstractMultiaddrConnection } from './abstract-multiaddr-connection.ts'
-import { MessageQueue } from './message-queue.ts'
-import type { SendResult } from './abstract-message-stream.ts'
-import type { AbstractMultiaddrConnectionInit } from './abstract-multiaddr-connection.ts'
-import type { MessageQueueEvents, MessageQueueInit } from './message-queue.ts'
-import type { AbortOptions, Logger, MultiaddrConnection, MessageStreamDirection, TypedEventTarget } from '@libp2p/interface'
-import type { Multiaddr } from '@multiformats/multiaddr'
-import type { Uint8ArrayList } from 'uint8arraylist'
-
-interface MockMultiaddrConnectionMessages extends MessageQueueEvents {
-  close: Event
-  pause: Event
-  resume: Event
-}
-
-export interface MockMultiaddrConnectionInit extends AbstractMultiaddrConnectionInit {
-  id: string,
-  log: Logger,
-  direction: MessageStreamDirection
-  local: MessageQueue<MockMultiaddrConnectionMessages>
-  remote: TypedEventTarget<MockMultiaddrConnectionMessages>
-  remoteAddr: Multiaddr
-}
-
-let multiaddrConnectionId = 0
-
-class MockMultiaddrConnection extends AbstractMultiaddrConnection {
-  private local: MessageQueue<MockMultiaddrConnectionMessages>
-  private remote: TypedEventTarget<MockMultiaddrConnectionMessages>
-
-  constructor (init: MockMultiaddrConnectionInit) {
-    super(init)
-
-    this.local = init.local
-    this.remote = init.remote
-
-    this.local.addEventListener('drain', () => {
-      this.safeDispatchEvent('drain')
-    })
-
-    this.remote.addEventListener('message', (evt) => {
-      if (this.status !== 'open') {
-        return
-      }
-
-      this.onData(evt.data)
-    })
-    this.remote.addEventListener('reset', (evt) => {
-      if (this.status !== 'open') {
-        return
-      }
-
-      this.onRemoteReset()
-    })
-    this.remote.addEventListener('close', (evt) => {
-      this.onTransportClosed()
-    })
-    this.remote.addEventListener('pause', (evt) => {
-      this.local.pause()
-    })
-    this.remote.addEventListener('resume', (evt) => {
-      this.local.resume()
-    })
-  }
-
-  sendData (data: Uint8ArrayList): SendResult {
-    const canSendMore = this.local.send(new StreamMessageEvent(data))
-
-    return {
-      sentBytes: data.byteLength,
-      canSendMore
-    }
-  }
-
-  sendReset (): void {
-    this.local.send(new Event('reset'))
-  }
-
-  async sendClose (options?: AbortOptions): Promise<void> {
-    if (this.local.needsDrain) {
-      await pEvent(this.local, 'drain', {
-        signal: options?.signal
-      })
-    }
-
-    return raceSignal(new Promise<void>((resolve, reject) => {
-      this.local.send(new Event('close'))
-      this.local.onIdle().then(resolve, reject)
-    }), options?.signal)
-  }
-
-  sendPause (): void {
-    this.local.send(new Event('pause'))
-  }
-
-  sendResume (): void {
-    this.local.send(new Event('resume'))
-  }
-}
-
-export interface MultiaddrConnectionPairOptions extends MessageQueueInit {
-  outbound?: Partial<MockMultiaddrConnectionInit>
-  inbound?: Partial<MockMultiaddrConnectionInit>
-}
-
-export function multiaddrConnectionPair (opts: MultiaddrConnectionPairOptions = {}): [MultiaddrConnection, MultiaddrConnection] {
-  const inboundId = `${multiaddrConnectionId++}`
-  const outboundId = `${multiaddrConnectionId++}`
-
-  const outboundLog = defaultLogger().forComponent(`libp2p:mock-maconn:outbound:${inboundId}`)
-  const inboundLog = defaultLogger().forComponent(`libp2p:mock-maconn:inbound:${outboundId}`)
-
-  const targetA = new MessageQueue<MockMultiaddrConnectionMessages>({
-    ...opts,
-    log: outboundLog
-  })
-  const targetB = new MessageQueue<MockMultiaddrConnectionMessages>({
-    ...opts,
-    log: inboundLog
-  })
-
-  return [
-    new MockMultiaddrConnection({
-      ...opts.outbound,
-      id: outboundId,
-      direction: 'outbound',
-      local: targetA,
-      remote: targetB,
-      remoteAddr: opts?.outbound?.remoteAddr ?? multiaddr(`/ip4/127.0.0.1/tcp/${outboundId}`),
-      log: outboundLog
-    }),
-    new MockMultiaddrConnection({
-      ...opts.inbound,
-      id: inboundId,
-      direction: 'inbound',
-      local: targetB,
-      remote: targetA,
-      remoteAddr: opts?.inbound?.remoteAddr ?? multiaddr(`/ip4/127.0.0.1/tcp/${inboundId}`),
-      log: inboundLog
-    })
-  ]
-}