@libp2p/utils 6.7.1 → 6.7.2-6059227cb

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

@@ -0,0 +1,112 @@
+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

@@ -0,0 +1,6 @@
+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/is-global-unicast.ts

@@ -1,5 +1,5 @@
 import { cidrContains } from '@chainsafe/netmask'
-import { CODE_IP6 } from '@multiformats/multiaddr'
+import { getNetConfig } from './get-net-config.ts'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 /**
@@ -7,18 +7,15 @@ import type { Multiaddr } from '@multiformats/multiaddr'
  */
 export function isGlobalUnicast (ma: Multiaddr): boolean {
   try {
-    for (const { code, value } of ma.getComponents()) {
-      if (value == null) {
-        continue
-      }
+    const config = getNetConfig(ma)
 
-      if (code === CODE_IP6) {
-        return cidrContains('2000::/3', value)
-      }
+    switch (config.type) {
+      case 'ip6':
+        return cidrContains('2000::/3', config.host)
+      default:
+        return false
     }
   } catch {
-
+    return false
   }
-
-  return false
 }

package/src/multiaddr/is-link-local.ts

@@ -1,4 +1,4 @@
-import { CODE_IP4, CODE_IP6, CODE_IP6ZONE } from '@multiformats/multiaddr'
+import { getNetConfig } from './get-net-config.ts'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 /**
@@ -6,26 +6,17 @@ import type { Multiaddr } from '@multiformats/multiaddr'
  */
 export function isLinkLocal (ma: Multiaddr): boolean {
   try {
-    for (const { code, value } of ma.getComponents()) {
-      if (code === CODE_IP6ZONE) {
-        continue
-      }
+    const config = getNetConfig(ma)
 
-      if (value == null) {
-        continue
-      }
-
-      if (code === CODE_IP4) {
-        return value.startsWith('169.254.')
-      }
-
-      if (code === CODE_IP6) {
-        return value.toLowerCase().startsWith('fe80')
-      }
+    switch (config.type) {
+      case 'ip4':
+        return config.host.startsWith('169.254.')
+      case 'ip6':
+        return config.host.toLowerCase().startsWith('fe80')
+      default:
+        return false
     }
-  } catch {
-
+  } catch (err) {
+    return false
   }
-
-  return false
 }

package/src/multiaddr/is-loopback.ts

@@ -1,17 +1,22 @@
 import { isLoopbackAddr } from 'is-loopback-addr'
-import { isIpBased } from './is-ip-based.js'
+import { getNetConfig } from './get-net-config.ts'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 /**
  * Check if a given multiaddr is a loopback address.
  */
 export function isLoopback (ma: Multiaddr): boolean {
-  if (!isIpBased(ma)) {
-    // not an IP based multiaddr, cannot be private
+  try {
+    const config = getNetConfig(ma)
+
+    switch (config.type) {
+      case 'ip4':
+      case 'ip6':
+        return isLoopbackAddr(config.host)
+      default:
+        return false
+    }
+  } catch {
     return false
   }
-
-  const { address } = ma.nodeAddress()
-
-  return isLoopbackAddr(address)
 }

package/src/multiaddr/is-network-address.ts

@@ -1,30 +1,15 @@
-import { CODE_IP4, CODE_IP6, CODE_IP6ZONE, CODE_DNS, CODE_DNS4, CODE_DNS6, CODE_DNSADDR } from '@multiformats/multiaddr'
+import { getNetConfig } from './get-net-config.ts'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
-const NETWORK_CODECS = [
-  CODE_IP4,
-  CODE_IP6,
-  CODE_DNS,
-  CODE_DNS4,
-  CODE_DNS6,
-  CODE_DNSADDR
-]
-
 /**
  * Check if a given multiaddr is a network address
  */
 export function isNetworkAddress (ma: Multiaddr): boolean {
   try {
-    for (const { code } of ma.getComponents()) {
-      if (code === CODE_IP6ZONE) {
-        continue
-      }
+    getNetConfig(ma)
 
-      return NETWORK_CODECS.includes(code)
-    }
+    return true
   } catch {
-
+    return false
   }
-
-  return false
 }

package/src/multiaddr/is-private.ts

@@ -1,5 +1,5 @@
 import { isPrivateIp } from '../private-ip.js'
-import { isIpBased } from './is-ip-based.js'
+import { getNetConfig } from './get-net-config.ts'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 /**
@@ -7,21 +7,16 @@ import type { Multiaddr } from '@multiformats/multiaddr'
  */
 export function isPrivate (ma: Multiaddr): boolean {
   try {
-    if (!isIpBased(ma)) {
-      // not an IP based multiaddr, cannot be private
-      return false
-    }
-
-    const [[, value]] = ma.stringTuples()
+    const config = getNetConfig(ma)
 
-    if (value == null) {
-      return false
+    switch (config.type) {
+      case 'ip4':
+      case 'ip6':
+        return isPrivateIp(config.host) ?? false
+      default:
+        return config.host === 'localhost'
     }
-
-    return isPrivateIp(value) ?? false
   } catch {
-
+    return false
   }
-
-  return true
 }

package/src/multiaddr/utils.ts

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,147 @@
+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
+    })
+  ]
+}

package/src/queue/index.ts

@@ -1,7 +1,7 @@
 import { AbortError } from '@libp2p/interface'
 import { pushable } from 'it-pushable'
 import { TypedEventEmitter } from 'main-event'
-import { raceEvent } from 'race-event'
+import { pEvent } from 'p-event'
 import { debounce } from '../debounce.js'
 import { QueueFullError } from '../errors.js'
 import { Job } from './job.js'
@@ -99,11 +99,6 @@ export interface QueueEvents<JobReturnType, JobOptions extends AbortOptions = Ab
    */
   completed: CustomEvent<JobReturnType>
 
-  /**
-   * A job has failed
-   */
-  error: CustomEvent<Error>
-
   /**
    * Emitted just after `"completed", a job has finished successfully - this
    * event gives access to the job and it's result
@@ -129,6 +124,7 @@ export class Queue<JobReturnType = unknown, JobOptions extends AbortOptions = Ab
   public queue: Array<Job<JobOptions, JobReturnType>>
   private pending: number
   private readonly sort?: Comparator<Job<JobOptions, JobReturnType>>
+  private paused: boolean
 
   constructor (init: QueueInit<JobReturnType, JobOptions> = {}) {
     super()
@@ -136,6 +132,7 @@ export class Queue<JobReturnType = unknown, JobOptions extends AbortOptions = Ab
     this.concurrency = init.concurrency ?? Number.POSITIVE_INFINITY
     this.maxSize = init.maxSize ?? Number.POSITIVE_INFINITY
     this.pending = 0
+    this.paused = false
 
     if (init.metricName != null) {
       init.metrics?.registerMetricGroup(init.metricName, {
@@ -172,7 +169,24 @@ export class Queue<JobReturnType = unknown, JobOptions extends AbortOptions = Ab
     this.safeDispatchEvent('idle')
   }
 
+  pause (): void {
+    this.paused = true
+  }
+
+  resume (): void {
+    if (!this.paused) {
+      return
+    }
+
+    this.paused = false
+    this.tryToStartAnother()
+  }
+
   private tryToStartAnother (): boolean {
+    if (this.paused) {
+      return false
+    }
+
     if (this.size === 0) {
       this.emitEmpty()
 
@@ -263,7 +277,6 @@ export class Queue<JobReturnType = unknown, JobOptions extends AbortOptions = Ab
           }
         }
 
-        this.safeDispatchEvent('error', { detail: err })
         this.safeDispatchEvent('failure', { detail: { job, error: err } })
 
         throw err
@@ -299,7 +312,7 @@ export class Queue<JobReturnType = unknown, JobOptions extends AbortOptions = Ab
       return
     }
 
-    await raceEvent(this, 'empty', options?.signal)
+    await pEvent(this, 'empty', options)
   }
 
   /**
@@ -319,7 +332,8 @@ export class Queue<JobReturnType = unknown, JobOptions extends AbortOptions = Ab
       return
     }
 
-    await raceEvent(this, 'next', options?.signal, {
+    await pEvent(this, 'next', {
+      ...options,
       filter: () => this.size < limit
     })
   }
@@ -338,7 +352,7 @@ export class Queue<JobReturnType = unknown, JobOptions extends AbortOptions = Ab
       return
     }
 
-    await raceEvent(this, 'idle', options?.signal)
+    await pEvent(this, 'idle', options)
   }
 
   /**
@@ -395,8 +409,8 @@ export class Queue<JobReturnType = unknown, JobOptions extends AbortOptions = Ab
       }
     }
 
-    const onQueueError = (evt: CustomEvent<Error>): void => {
-      cleanup(evt.detail)
+    const onQueueFailure = (evt: CustomEvent<QueueJobFailure<JobReturnType, JobOptions>>): void => {
+      cleanup(evt.detail.error)
     }
 
     const onQueueIdle = (): void => {
@@ -410,7 +424,7 @@ export class Queue<JobReturnType = unknown, JobOptions extends AbortOptions = Ab
 
     // add listeners
     this.addEventListener('completed', onQueueJobComplete)
-    this.addEventListener('error', onQueueError)
+    this.addEventListener('failure', onQueueFailure)
     this.addEventListener('idle', onQueueIdle)
     options?.signal?.addEventListener('abort', onSignalAbort)
 
@@ -419,7 +433,7 @@ export class Queue<JobReturnType = unknown, JobOptions extends AbortOptions = Ab
     } finally {
       // remove listeners
       this.removeEventListener('completed', onQueueJobComplete)
-      this.removeEventListener('error', onQueueError)
+      this.removeEventListener('failure', onQueueFailure)
       this.removeEventListener('idle', onQueueIdle)
       options?.signal?.removeEventListener('abort', onSignalAbort)
 

package/src/rate-limiter.ts

@@ -1,4 +1,3 @@
-import delay from 'delay'
 import { RateLimitError } from './errors.js'
 
 export interface RateLimiterInit {
@@ -23,20 +22,6 @@ export interface RateLimiterInit {
    */
   blockDuration?: number
 
-  /**
-   * Execute allowed actions evenly over duration
-   *
-   * @default false
-   */
-  execEvenly?: boolean
-
-  /**
-   * ms, works with execEvenly=true option
-   *
-   * @default duration * 1000 / points
-   */
-  execEvenlyMinDelayMs?: number
-
   /**
    * @default "rlflx"
    */
@@ -65,21 +50,17 @@ export class RateLimiter {
   protected points: number
   protected duration: number
   protected blockDuration: number
-  protected execEvenly: boolean
-  protected execEvenlyMinDelayMs: number
   protected keyPrefix: string
 
   constructor (opts: RateLimiterInit = {}) {
     this.points = opts.points ?? 4
     this.duration = opts.duration ?? 1
     this.blockDuration = opts.blockDuration ?? 0
-    this.execEvenly = opts.execEvenly ?? false
-    this.execEvenlyMinDelayMs = opts.execEvenlyMinDelayMs ?? (this.duration * 1000 / this.points)
     this.keyPrefix = opts.keyPrefix ?? 'rlflx'
     this.memoryStorage = new MemoryStorage()
   }
 
-  async consume (key: string, pointsToConsume: number = 1, options: GetKeySecDurationOptions = {}): Promise<RateLimiterResult> {
+  consume (key: string, pointsToConsume: number = 1, options: GetKeySecDurationOptions = {}): RateLimiterResult {
     const rlKey = this.getKey(key)
     const secDuration = this._getKeySecDuration(options)
     let res = this.memoryStorage.incrby(rlKey, pointsToConsume, secDuration)
@@ -93,14 +74,6 @@ export class RateLimiter {
       }
 
       throw new RateLimitError('Rate limit exceeded', res)
-    } else if (this.execEvenly && res.msBeforeNext > 0 && !res.isFirstInDuration) {
-      // Execute evenly
-      let delayMs = Math.ceil(res.msBeforeNext / (res.remainingPoints + 2))
-      if (delayMs < this.execEvenlyMinDelayMs) {
-        delayMs = res.consumedPoints * this.execEvenlyMinDelayMs
-      }
-
-      await delay(delayMs)
     }
 
     return res
@@ -241,8 +214,8 @@ export class MemoryStorage {
         this.storage.delete(key)
       }, durationMs)
 
-      if (record.timeoutId.unref != null) {
-        record.timeoutId.unref()
+      if ((record.timeoutId as any).unref != null) {
+        (record.timeoutId as any).unref()
       }
     }