@libp2p/utils 6.7.2-6059227cb → 6.7.2-87bc8d4fb

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,34 +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 './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 './tracked-list.js'
-export * from './tracked-map.js'
+export {}

package/src/merge-options.ts

@@ -0,0 +1,161 @@
+import isOptionObject from 'is-plain-obj'
+
+const { hasOwnProperty } = Object.prototype
+const { propertyIsEnumerable } = Object
+const defineProperty = (object: any, name: any, value: any): void => {
+  Object.defineProperty(object, name, {
+    value,
+    writable: true,
+    enumerable: true,
+    configurable: true
+  })
+}
+
+const globalThis = this
+const defaultMergeOptions = {
+  concatArrays: false,
+  ignoreUndefined: false
+}
+
+const getEnumerableOwnPropertyKeys = (value: any): any[] => {
+  const keys = []
+
+  for (const key in value) {
+    if (hasOwnProperty.call(value, key)) {
+      keys.push(key)
+    }
+  }
+
+  /* istanbul ignore else  */
+  if (Object.getOwnPropertySymbols) {
+    const symbols = Object.getOwnPropertySymbols(value)
+
+    for (const symbol of symbols) {
+      if (propertyIsEnumerable.call(value, symbol)) {
+        keys.push(symbol)
+      }
+    }
+  }
+
+  return keys
+}
+
+function clone <T> (value: T): T
+function clone <T> (value: T[]): T[]
+function clone (value: any): any {
+  if (Array.isArray(value)) {
+    return cloneArray(value)
+  }
+
+  if (isOptionObject(value)) {
+    return cloneOptionObject(value)
+  }
+
+  return value
+}
+
+function cloneArray <T> (array: T[]): T[] {
+  const result = array.slice(0, 0)
+
+  getEnumerableOwnPropertyKeys(array).forEach(key => {
+    defineProperty(result, key, clone(array[key]))
+  })
+
+  return result
+}
+
+function cloneOptionObject (object: any): any {
+  const result = Object.getPrototypeOf(object) === null ? Object.create(null) : {}
+
+  getEnumerableOwnPropertyKeys(object).forEach(key => {
+    defineProperty(result, key, clone(object[key]))
+  })
+
+  return result
+}
+
+const mergeKeys = (merged: any, source: any, keys: any[], config: any): any => {
+  keys.forEach(key => {
+    if (typeof source[key] === 'undefined' && config.ignoreUndefined) {
+      return
+    }
+
+    // Do not recurse into prototype chain of merged
+    if (key in merged && merged[key] !== Object.getPrototypeOf(merged)) {
+      defineProperty(merged, key, merge(merged[key], source[key], config))
+    } else {
+      defineProperty(merged, key, clone(source[key]))
+    }
+  })
+
+  return merged
+}
+
+/**
+ * see [Array.prototype.concat ( ...arguments )](http://www.ecma-international.org/ecma-262/6.0/#sec-array.prototype.concat)
+ */
+const concatArrays = (merged: any, source: any, config: any): any => {
+  let result = merged.slice(0, 0)
+  let resultIndex = 0;
+
+  [merged, source].forEach(array => {
+    const indices: any[] = []
+
+    // `result.concat(array)` with cloning
+    for (let k = 0; k < array.length; k++) {
+      if (!hasOwnProperty.call(array, k)) {
+        continue
+      }
+
+      indices.push(String(k))
+
+      if (array === merged) {
+        // Already cloned
+        defineProperty(result, resultIndex++, array[k])
+      } else {
+        defineProperty(result, resultIndex++, clone(array[k]))
+      }
+    }
+
+    // Merge non-index keys
+    result = mergeKeys(result, array, getEnumerableOwnPropertyKeys(array).filter(key => !indices.includes(key)), config)
+  })
+
+  return result
+}
+
+function merge (merged: any, source: any, config: any): any {
+  if (config.concatArrays && Array.isArray(merged) && Array.isArray(source)) {
+    return concatArrays(merged, source, config)
+  }
+
+  if (!isOptionObject(source) || !isOptionObject(merged)) {
+    return clone(source)
+  }
+
+  return mergeKeys(merged, source, getEnumerableOwnPropertyKeys(source), config)
+}
+
+/**
+ * Port of `merge-options` to typescript
+ *
+ * @see https://github.com/schnittstabil/merge-options/pull/28
+ */
+export function mergeOptions (this: any, ...options: any[]): any {
+  const config = merge(clone(defaultMergeOptions), (this !== globalThis && this) || {}, defaultMergeOptions)
+  let merged = { _: {} }
+
+  for (const option of options) {
+    if (option === undefined) {
+      continue
+    }
+
+    if (!isOptionObject(option)) {
+      throw new TypeError('`' + option + '` is not an Option Object')
+    }
+
+    merged = merge(merged, { _: option }, config)
+  }
+
+  return merged._
+}

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'
@@ -99,6 +99,13 @@ export interface QueueEvents<JobReturnType, JobOptions extends AbortOptions = Ab
    */
   completed: CustomEvent<JobReturnType>
 
+  /**
+   * A job has failed
+   *
+   * @deprecated Listen for the 'failure' event instead - it gives more context and is generally more useful, this event will be removed in a future release
+   */
+  error: CustomEvent<Error>
+
   /**
    * Emitted just after `"completed", a job has finished successfully - this
    * event gives access to the job and it's result
@@ -124,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()
@@ -132,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, {
@@ -169,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()
 
@@ -312,7 +300,7 @@ export class Queue<JobReturnType = unknown, JobOptions extends AbortOptions = Ab
       return
     }
 
-    await pEvent(this, 'empty', options)
+    await raceEvent(this, 'empty', options?.signal)
   }
 
   /**
@@ -332,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
     })
   }
@@ -352,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()
       }
     }