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

package/src/close.ts

@@ -0,0 +1,65 @@
+import type { Connection, Stream, AbortOptions } from '@libp2p/interface'
+
+/**
+ * Close the passed stream, falling back to aborting the stream if closing
+ * cleanly fails.
+ */
+export async function safelyCloseStream (stream?: Stream, options?: AbortOptions): Promise<void> {
+  try {
+    await stream?.close(options)
+  } catch (err: any) {
+    stream?.abort(err)
+  }
+}
+
+/**
+ * These are speculative protocols that are run automatically on connection open
+ * so are usually not the reason the connection was opened.
+ *
+ * Consequently when requested it should be safe to close connections that only
+ * have these protocol streams open.
+ */
+const DEFAULT_CLOSABLE_PROTOCOLS = [
+  // identify
+  '/ipfs/id/1.0.0',
+
+  // identify-push
+  '/ipfs/id/push/1.0.0',
+
+  // autonat
+  '/libp2p/autonat/1.0.0',
+
+  // dcutr
+  '/libp2p/dcutr'
+]
+
+export interface SafelyCloseConnectionOptions extends AbortOptions {
+  /**
+   * Only close the stream if it either has no protocol streams open or only
+   * ones in this list.
+   *
+   * @default ['/ipfs/id/1.0.0']
+   */
+  closableProtocols?: string[]
+}
+
+/**
+ * Close the passed connection if it has no streams, or only closable protocol
+ * streams, falling back to aborting the connection if closing it cleanly fails.
+ */
+export async function safelyCloseConnectionIfUnused (connection?: Connection, options?: SafelyCloseConnectionOptions): Promise<void> {
+  const streamProtocols = connection?.streams?.map(stream => stream.protocol) ?? []
+  const closableProtocols = options?.closableProtocols ?? DEFAULT_CLOSABLE_PROTOCOLS
+
+  // if the connection has protocols not in the closable protocols list, do not
+  // close the connection
+  if (streamProtocols.filter(proto => proto != null && !closableProtocols.includes(proto)).length > 0) {
+    return
+  }
+
+  try {
+    await connection?.close(options)
+  } catch (err: any) {
+    connection?.abort(err)
+  }
+}

package/src/errors.ts

@@ -27,13 +27,3 @@ export class QueueFullError extends Error {
     this.name = 'QueueFullError'
   }
 }
-
-export class UnexpectedEOFError extends Error {
-  static name = 'UnexpectedEOFError'
-  name = 'UnexpectedEOFError'
-}
-
-export class MaxEarlyStreamsError extends Error {
-  static name = 'MaxEarlyStreamsError'
-  name = 'MaxEarlyStreamsError'
-}

package/src/get-thin-waist-addresses.browser.ts

@@ -1,5 +1,4 @@
-import { getNetConfig } from './multiaddr/get-net-config.ts'
-import { netConfigToMultiaddr } from './multiaddr/utils.ts'
+import { multiaddr } from '@multiformats/multiaddr'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 /**
@@ -8,14 +7,14 @@ import type { Multiaddr } from '@multiformats/multiaddr'
  *
  * Wildcard IP4/6 addresses will be expanded into all available interfaces.
  */
-export function getThinWaistAddresses (ma?: Multiaddr, port?: number | string): Multiaddr[] {
+export function getThinWaistAddresses (ma?: Multiaddr, port?: number): Multiaddr[] {
   if (ma == null) {
     return []
   }
 
-  const config = getNetConfig(ma)
+  const options = ma.toOptions()
 
   return [
-    netConfigToMultiaddr(config, port)
+    multiaddr(`/ip${options.family}/${options.host}/${options.transport}/${port ?? options.port}`)
   ]
 }

package/src/get-thin-waist-addresses.ts

@@ -1,7 +1,6 @@
 import os from 'node:os'
+import { multiaddr } from '@multiformats/multiaddr'
 import { isLinkLocalIp } from './link-local-ip.js'
-import { getNetConfig } from './multiaddr/get-net-config.ts'
-import { netConfigToMultiaddr } from './multiaddr/utils.ts'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 const FAMILIES = { 4: 'IPv4', 6: 'IPv6' }
@@ -37,19 +36,24 @@ function getNetworkAddrs (family: 4 | 6): string[] {
  *
  * Wildcard IP4/6 addresses will be expanded into all available interfaces.
  */
-export function getThinWaistAddresses (ma?: Multiaddr, port?: number | string): Multiaddr[] {
+export function getThinWaistAddresses (ma?: Multiaddr, port?: number): Multiaddr[] {
   if (ma == null) {
     return []
   }
 
-  const config = getNetConfig(ma)
+  const options = ma.toOptions()
 
-  if ((config.type === 'ip4' || config.type === 'ip6') && isWildcard(config.host)) {
-    return getNetworkAddrs(config.type === 'ip4' ? 4 : 6)
-      .map(host => netConfigToMultiaddr(config, port, host))
+  if (isWildcard(options.host)) {
+    const addrs = []
+
+    for (const host of getNetworkAddrs(options.family)) {
+      addrs.push(multiaddr(`/ip${options.family}/${host}/${options.transport}/${port ?? options.port}`))
+    }
+
+    return addrs
   }
 
   return [
-    netConfigToMultiaddr(config, port)
+    multiaddr(`/ip${options.family}/${options.host}/${options.transport}/${port ?? options.port}`)
   ]
 }

package/src/index.ts

@@ -4,36 +4,4 @@
  * This module contains utility functions used by libp2p modules.
  */
 
-export * from './filters/index.js'
-export * from './multiaddr/index.js'
-export * from './queue/index.js'
-export * from './abstract-message-stream.js'
-export * from './abstract-multiaddr-connection.js'
-export * from './abstract-stream-muxer.js'
-export * from './abstract-stream.js'
-export * from './adaptive-timeout.js'
-export * from './debounce.js'
-export * from './errors.js'
-export * from './get-thin-waist-addresses.js'
-export * from './global-unicast-ip.js'
-export * from './ip-port-to-multiaddr.js'
-export * from './is-async-generator.js'
-export * from './is-generator.js'
-export * from './is-promise.js'
-export * from './length-prefixed-decoder.js'
-export * from './link-local-ip.js'
-export * from './merge-options.js'
-export * from './mock-muxer.js'
-export * from './mock-stream.js'
-export * from './moving-average.js'
-export * from './multiaddr-connection-pair.js'
-export * from './peer-queue.js'
-export * from './priority-queue.js'
-export * from './private-ip.js'
-export * from './rate-limiter.js'
-export * from './repeating-task.js'
-export * from './stream-pair.js'
-export * from './stream-utils.js'
-export * from './socket-writer.js'
-export * from './tracked-list.js'
-export * from './tracked-map.js'
+export {}

package/src/multiaddr/is-global-unicast.ts

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

package/src/multiaddr/is-ip-based.ts

@@ -0,0 +1,21 @@
+import { CODE_IP4, CODE_IP6, CODE_IP6ZONE } from '@multiformats/multiaddr'
+import type { Multiaddr } from '@multiformats/multiaddr'
+
+/**
+ * Check if a given multiaddr is IP-based
+ */
+export function isIpBased (ma: Multiaddr): boolean {
+  try {
+    for (const { code } of ma.getComponents()) {
+      if (code === CODE_IP6ZONE) {
+        continue
+      }
+
+      return code === CODE_IP4 || code === CODE_IP6
+    }
+  } catch {
+
+  }
+
+  return false
+}

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

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

package/src/multiaddr/is-loopback.ts

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

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

@@ -1,15 +1,30 @@
-import { getNetConfig } from './get-net-config.ts'
+import { CODE_IP4, CODE_IP6, CODE_IP6ZONE, CODE_DNS, CODE_DNS4, CODE_DNS6, CODE_DNSADDR } from '@multiformats/multiaddr'
 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 {
-    getNetConfig(ma)
+    for (const { code } of ma.getComponents()) {
+      if (code === CODE_IP6ZONE) {
+        continue
+      }
 
-    return true
+      return NETWORK_CODECS.includes(code)
+    }
   } catch {
-    return false
+
   }
+
+  return false
 }

package/src/multiaddr/is-private.ts

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

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 { pEvent } from 'p-event'
+import { raceEvent } from 'race-event'
 import { debounce } from '../debounce.js'
 import { QueueFullError } from '../errors.js'
 import { Job } from './job.js'
@@ -131,7 +131,6 @@ 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()
@@ -139,7 +138,6 @@ 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, {
@@ -176,24 +174,7 @@ 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()
 
@@ -319,7 +300,7 @@ export class Queue<JobReturnType = unknown, JobOptions extends AbortOptions = Ab
       return
     }
 
-    await pEvent(this, 'empty', options)
+    await raceEvent(this, 'empty', options?.signal)
   }
 
   /**
@@ -339,8 +320,7 @@ export class Queue<JobReturnType = unknown, JobOptions extends AbortOptions = Ab
       return
     }
 
-    await pEvent(this, 'next', {
-      ...options,
+    await raceEvent(this, 'next', options?.signal, {
       filter: () => this.size < limit
     })
   }
@@ -359,7 +339,7 @@ export class Queue<JobReturnType = unknown, JobOptions extends AbortOptions = Ab
       return
     }
 
-    await pEvent(this, 'idle', options)
+    await raceEvent(this, 'idle', options?.signal)
   }
 
   /**

package/src/rate-limiter.ts

@@ -1,3 +1,4 @@
+import delay from 'delay'
 import { RateLimitError } from './errors.js'
 
 export interface RateLimiterInit {
@@ -22,6 +23,20 @@ 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"
    */
@@ -50,17 +65,21 @@ 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()
   }
 
-  consume (key: string, pointsToConsume: number = 1, options: GetKeySecDurationOptions = {}): RateLimiterResult {
+  async consume (key: string, pointsToConsume: number = 1, options: GetKeySecDurationOptions = {}): Promise<RateLimiterResult> {
     const rlKey = this.getKey(key)
     const secDuration = this._getKeySecDuration(options)
     let res = this.memoryStorage.incrby(rlKey, pointsToConsume, secDuration)
@@ -74,6 +93,14 @@ 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
@@ -214,8 +241,8 @@ export class MemoryStorage {
         this.storage.delete(key)
       }, durationMs)
 
-      if ((record.timeoutId as any).unref != null) {
-        (record.timeoutId as any).unref()
+      if (record.timeoutId.unref != null) {
+        record.timeoutId.unref()
       }
     }
 

package/src/stream-to-ma-conn.ts

@@ -0,0 +1,106 @@
+import forEach from 'it-foreach'
+import { pipe } from 'it-pipe'
+import type { Logger, MultiaddrConnection, Stream } from '@libp2p/interface'
+import type { Multiaddr } from '@multiformats/multiaddr'
+import type { Uint8ArrayList } from 'uint8arraylist'
+
+export interface StreamProperties {
+  stream: Stream
+  remoteAddr: Multiaddr
+  localAddr: Multiaddr
+  log: Logger
+
+  /**
+   * 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 duplex iterable into a MultiaddrConnection.
+ * https://github.com/libp2p/interface-transport#multiaddrconnection
+ */
+export function streamToMaConnection (props: StreamProperties): MultiaddrConnection {
+  const { stream, remoteAddr, log, onDataRead, onDataWrite } = props
+
+  let closedRead = false
+  let closedWrite = false
+
+  // piggyback on `stream.close` invocations to close multiaddr connection
+  const streamClose = stream.close.bind(stream)
+  stream.close = async (options): Promise<void> => {
+    await streamClose(options)
+    close(true)
+  }
+
+  // piggyback on `stream.abort` invocations to close multiaddr connection
+  const streamAbort = stream.abort.bind(stream)
+  stream.abort = (err): void => {
+    streamAbort(err)
+    close(true)
+  }
+
+  // piggyback on `stream.sink` invocations to close multiaddr connection
+  const streamSink = stream.sink.bind(stream)
+  stream.sink = async (source): Promise<void> => {
+    try {
+      await streamSink(
+        pipe(
+          source,
+          (source) => forEach(source, buf => onDataWrite?.(buf))
+        )
+      )
+    } catch (err: any) {
+      maConn.log.error('errored - %e', err)
+
+      // If aborted we can safely ignore
+      if (err.type !== 'aborted') {
+        // If the source errored the socket will already have been destroyed by
+        // toIterable.duplex(). If the socket errored it will already be
+        // destroyed. There's nothing to do here except log the error & return.
+        maConn.log.error('%s error in sink - %e', remoteAddr, err)
+      }
+    } finally {
+      closedWrite = true
+      close()
+    }
+  }
+
+  const maConn: MultiaddrConnection = {
+    log: log.newScope('stream-to-maconn'),
+    sink: stream.sink,
+    source: (async function * (): AsyncGenerator<Uint8ArrayList> {
+      try {
+        for await (const buf of stream.source) {
+          onDataRead?.(buf)
+          yield buf
+        }
+      } finally {
+        closedRead = true
+        close()
+      }
+    }()),
+    remoteAddr,
+    timeline: { open: Date.now(), close: undefined },
+    close: stream.close,
+    abort: stream.abort
+  }
+
+  function close (force?: boolean): void {
+    if (force === true) {
+      closedRead = true
+      closedWrite = true
+    }
+
+    if (closedRead && closedWrite && maConn.timeline.close == null) {
+      maConn.timeline.close = Date.now()
+    }
+  }
+
+  return maConn
+}