libp2p 0.42.2-593deefe → 0.42.2-5e63ee2d

package/src/circuit/utils.ts

@@ -5,140 +5,101 @@ import type { Uint8ArrayList } from 'uint8arraylist'
 import type { Limit } from './pb/index.js'
 import { logger } from '@libp2p/logger'
 import type { Stream } from '@libp2p/interface-connection'
+import { DEFAULT_DATA_LIMIT, DEFAULT_DURATION_LIMIT } from './constants.js'
+import { abortableSource } from 'abortable-iterator'
+import anySignal from 'any-signal'
 
-const log = logger('libp2p:circuit:v2:util')
+const log = logger('libp2p:circuit-relay:utils')
 
-const doRelay = (src: Stream, dst: Stream) => {
-  queueMicrotask(() => {
-    void dst.sink(src.source).catch(err => log.error('error while relating streams:', err))
-  })
+async function * countStreamBytes (source: Source<Uint8Array | Uint8ArrayList>, limit: { remaining: bigint }): AsyncGenerator<Uint8Array | Uint8ArrayList, void, unknown> {
+  for await (const buf of source) {
+    const len = BigInt(buf.byteLength)
 
-  queueMicrotask(() => {
-    void src.sink(dst.source).catch(err => log.error('error while relaying streams:', err))
-  })
-}
+    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
 
-export function createLimitedRelay (source: Stream, destination: Stream, limit?: Limit) {
-  // trivial case
-  if (limit == null) {
-    doRelay(source, destination)
-    return
-  }
-
-  const dataLimit = limit.data ?? 0n
-  const durationLimit = limit.duration ?? 0
-  const src = durationLimitDuplex(dataLimitDuplex(source, dataLimit), durationLimit)
-  const dst = durationLimitDuplex(dataLimitDuplex(destination, dataLimit), durationLimit)
-
-  doRelay(src, dst)
-}
-
-const dataLimitSource = (stream: Stream, limit: bigint): Stream => {
-  if (limit === 0n) {
-    return stream
-  }
-
-  const source = stream.source
-
-  stream.source = (async function * (): Source<Uint8ArrayList> {
-    let total = 0n
-
-    for await (const buf of source) {
-      const len = BigInt(buf.byteLength)
-      if (total + len > limit) {
-        // this is a safe downcast since len is guarantee to be in the range for a number
-        const remaining = Number(limit - total)
-        try {
-          if (remaining !== 0) {
-            yield buf
-          }
-        } finally {
-          stream.abort(new Error('data limit exceeded'))
+      try {
+        if (remaining !== 0) {
+          yield buf.subarray(0, remaining)
         }
-        return
+      } catch (err: any) {
+        log.error(err)
       }
 
-      yield buf
-
-      total += len
+      throw new Error('data limit exceeded')
     }
-  })()
 
-  return stream
-}
-
-const dataLimitSink = (stream: Stream, limit: bigint): Stream => {
-  if (limit === 0n) {
-    return stream
+    limit.remaining -= len
+    yield buf
   }
+}
 
-  const sink = stream.sink
-
-  stream.sink = async (source: Source<Uint8ArrayList | Uint8Array>) => {
-    await sink((async function * (): Source<Uint8ArrayList | Uint8Array> {
-      let total = 0n
-
-      for await (const buf of source) {
-        const len = BigInt(buf.byteLength)
-        if (total + len > limit) {
-          // this is a safe downcast since len is guarantee to be in the range for a number
-          const remaining = Number(limit - total)
-          try {
-            if (remaining !== 0) {
-              yield buf.subarray(0, remaining)
-            }
-          } finally {
-            stream.abort(new Error('data limit exceeded'))
-          }
-          return
-        }
-
-        total += len
-        yield buf
-      }
-    })())
+const doRelay = (src: Stream, dst: Stream, abortSignal: AbortSignal, limit: Required<Limit>): void => {
+  function abortStreams (err: Error): void {
+    src.abort(err)
+    dst.abort(err)
+    clearTimeout(timeout)
   }
 
-  return stream
-}
+  const abortController = new AbortController()
+  const signal = anySignal([abortSignal, abortController.signal])
 
-const dataLimitDuplex = (stream: Stream, limit: bigint): Stream => {
-  dataLimitSource(stream, limit)
-  dataLimitSink(stream, limit)
+  const timeout = setTimeout(() => {
+    abortController.abort()
+  }, limit.duration)
 
-  return stream
-}
+  let srcDstFinished = false
+  let dstSrcFinished = false
 
-const durationLimitDuplex = (stream: Stream, limit: number): Stream => {
-  if (limit === 0) {
-    return stream
+  const dataLimit = {
+    remaining: limit.data
   }
 
-  let timedOut = false
-  const timeout = setTimeout(
-    () => {
-      timedOut = true
-      stream.abort(new Error('exceeded connection duration limit'))
-    },
-    limit
-  )
-
-  const source = stream.source
-
-  stream.source = (async function * (): Source<Uint8ArrayList> {
-    try {
-      for await (const buf of source) {
-        if (timedOut) {
-          return
+  queueMicrotask(() => {
+    void dst.sink(countStreamBytes(abortableSource(src.source, signal, {
+      abortMessage: 'duration limit exceeded'
+    }), dataLimit))
+      .catch(err => {
+        log.error('error while relaying streams src -> dst', err)
+        abortStreams(err)
+      })
+      .finally(() => {
+        srcDstFinished = true
+
+        if (dstSrcFinished) {
+          clearTimeout(timeout)
         }
-        yield buf
-      }
-    } finally {
-      clearTimeout(timeout)
-    }
-  })()
+      })
+  })
 
-  return stream
+  queueMicrotask(() => {
+    void src.sink(countStreamBytes(abortableSource(dst.source, signal, {
+      abortMessage: 'duration limit exceeded'
+    }), dataLimit))
+      .catch(err => {
+        log.error('error while relaying streams dst -> src', err)
+        abortStreams(err)
+      })
+      .finally(() => {
+        dstSrcFinished = true
+
+        if (srcDstFinished) {
+          clearTimeout(timeout)
+        }
+      })
+  })
+}
+
+export function createLimitedRelay (source: Stream, destination: Stream, abortSignal: AbortSignal, limit?: Limit): void {
+  const dataLimit = limit?.data ?? BigInt(DEFAULT_DATA_LIMIT)
+  const durationLimit = limit?.duration ?? DEFAULT_DURATION_LIMIT
+
+  doRelay(source, destination, abortSignal, {
+    data: dataLimit,
+    duration: durationLimit
+  })
 }
 
 /**
@@ -151,7 +112,9 @@ export async function namespaceToCid (namespace: string): Promise<CID> {
   return CID.createV0(hash)
 }
 
-/** returns number of ms beween now and expiration time */
+/**
+ * returns number of ms between now and expiration time
+ */
 export function getExpiration (expireTime: bigint): number {
   return Number(expireTime) - new Date().getTime()
 }

package/src/components.ts

@@ -1,5 +1,5 @@
 import errCode from 'err-code'
-import type { ConnectionGater, ConnectionProtector } from '@libp2p/interface-connection'
+import type { ConnectionProtector } from '@libp2p/interface-connection'
 import type { ContentRouting } from '@libp2p/interface-content-routing'
 import type { AddressManager } from '@libp2p/interface-address-manager'
 import { isStartable, Startable } from '@libp2p/interfaces/startable'
@@ -13,6 +13,7 @@ import type { Datastore } from 'interface-datastore'
 import type { PubSub } from '@libp2p/interface-pubsub'
 import type { DualDHT } from '@libp2p/interface-dht'
 import type { ConnectionManager, Dialer } from '@libp2p/interface-connection-manager'
+import type { ConnectionGater } from '@libp2p/interface-connection-gater'
 
 export interface Components {
   peerId: PeerId
@@ -90,11 +91,11 @@ export class DefaultComponents implements Components, Startable {
     this._dialer = init.dialer
   }
 
-  isStarted () {
+  isStarted (): boolean {
     return this._started
   }
 
-  async beforeStart () {
+  async beforeStart (): Promise<void> {
     await Promise.all(
       Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
         if (startable.beforeStart != null) {
@@ -104,7 +105,7 @@ export class DefaultComponents implements Components, Startable {
     )
   }
 
-  async start () {
+  async start (): Promise<void> {
     await Promise.all(
       Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
         await startable.start()
@@ -114,7 +115,7 @@ export class DefaultComponents implements Components, Startable {
     this._started = true
   }
 
-  async afterStart () {
+  async afterStart (): Promise<void> {
     await Promise.all(
       Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
         if (startable.afterStart != null) {
@@ -124,7 +125,7 @@ export class DefaultComponents implements Components, Startable {
     )
   }
 
-  async beforeStop () {
+  async beforeStop (): Promise<void> {
     await Promise.all(
       Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
         if (startable.beforeStop != null) {
@@ -134,7 +135,7 @@ export class DefaultComponents implements Components, Startable {
     )
   }
 
-  async stop () {
+  async stop (): Promise<void> {
     await Promise.all(
       Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
         await startable.stop()
@@ -144,7 +145,7 @@ export class DefaultComponents implements Components, Startable {
     this._started = false
   }
 
-  async afterStop () {
+  async afterStop (): Promise<void> {
     await Promise.all(
       Object.values(this).filter(obj => isStartable(obj)).map(async (startable: Startable) => {
         if (startable.afterStop != null) {

package/src/config.ts

@@ -2,7 +2,6 @@ import mergeOptions from 'merge-options'
 import { dnsaddrResolver } from '@multiformats/multiaddr/resolvers'
 import * as Constants from './constants.js'
 import { AGENT_VERSION } from './identify/consts.js'
-import * as RelayConstants from './circuit/constants.js'
 import { publicAddressesFirst } from '@libp2p/utils/address-sort'
 import { FaultTolerance } from '@libp2p/interface-transport'
 import type { Multiaddr } from '@multiformats/multiaddr'
@@ -22,7 +21,6 @@ const DefaultConfig: Partial<Libp2pInit> = {
   connectionManager: {
     maxConnections: 300,
     minConnections: 50,
-    autoDial: true,
     autoDialInterval: 10000,
     maxParallelDials: Constants.MAX_PARALLEL_DIALS,
     maxDialsPerPeer: Constants.MAX_PER_PEER_DIALS,
@@ -49,22 +47,6 @@ const DefaultConfig: Partial<Libp2pInit> = {
     ttl: 7200,
     keepAlive: true
   },
-  relay: {
-    enabled: true,
-    advertise: {
-      bootDelay: RelayConstants.ADVERTISE_BOOT_DELAY,
-      enabled: false,
-      ttl: RelayConstants.ADVERTISE_TTL
-    },
-    hop: {
-      enabled: false,
-      timeout: 30000
-    },
-    reservationManager: {
-      enabled: false,
-      maxReservations: 2
-    }
-  },
   identify: {
     protocolPrefix: 'ipfs',
     host: {
@@ -75,11 +57,18 @@ const DefaultConfig: Partial<Libp2pInit> = {
     maxInboundStreams: 1,
     maxOutboundStreams: 1,
     maxPushIncomingStreams: 1,
-    maxPushOutgoingStreams: 1
+    maxPushOutgoingStreams: 1,
+    maxObservedAddresses: 10
   },
   ping: {
     protocolPrefix: 'ipfs',
-    maxInboundStreams: 1,
+    // See https://github.com/libp2p/specs/blob/d4b5fb0152a6bb86cfd9ea/ping/ping.md?plain=1#L38-L43
+    // The dialing peer MUST NOT keep more than one outbound stream for the ping protocol per peer.
+    // The listening peer SHOULD accept at most two streams per peer since cross-stream behavior is
+    // non-linear and stream writes occur asynchronously. The listening peer may perceive the
+    // dialing peer closing and opening the wrong streams (for instance, closing stream B and
+    // opening stream A even though the dialing peer is opening stream B and closing stream A).
+    maxInboundStreams: 2,
     maxOutboundStreams: 1,
     timeout: 10000
   },
@@ -88,6 +77,14 @@ const DefaultConfig: Partial<Libp2pInit> = {
     maxInboundStreams: 1,
     maxOutboundStreams: 1,
     timeout: 10000
+  },
+  autonat: {
+    protocolPrefix: 'libp2p',
+    maxInboundStreams: 1,
+    maxOutboundStreams: 1,
+    timeout: 30000,
+    startupDelay: 5000,
+    refreshInterval: 60000
   }
 }
 

package/src/connection/index.ts

@@ -87,18 +87,18 @@ export class ConnectionImpl implements Connection {
     this._closing = false
   }
 
-  get [Symbol.toStringTag] () {
+  get [Symbol.toStringTag] (): 'Connection' {
     return 'Connection'
   }
 
-  get [symbol] () {
+  get [symbol] (): true {
     return true
   }
 
   /**
    * Get all the streams of the muxer
    */
-  get streams () {
+  get streams (): Stream[] {
     return this._getStreams()
   }
 
@@ -128,21 +128,21 @@ export class ConnectionImpl implements Connection {
   /**
    * Add a stream when it is opened to the registry
    */
-  addStream (stream: Stream) {
+  addStream (stream: Stream): void {
     stream.stat.direction = 'inbound'
   }
 
   /**
    * Remove stream registry after it is closed
    */
-  removeStream (id: string) {
+  removeStream (id: string): void {
 
   }
 
   /**
    * Close the connection
    */
-  async close () {
+  async close (): Promise<void> {
     if (this.stat.status === CLOSED || this._closing) {
       return
     }
@@ -151,7 +151,7 @@ export class ConnectionImpl implements Connection {
 
     // close all streams - this can throw if we're not multiplexed
     try {
-      this.streams.forEach(s => s.close())
+      this.streams.forEach(s => { s.close() })
     } catch (err) {
       log.error(err)
     }

package/src/connection-manager/auto-dialler.ts

@@ -10,11 +10,6 @@ import type { PeerStore } from '@libp2p/interface-peer-store'
 const log = logger('libp2p:connection-manager:auto-dialler')
 
 export interface AutoDiallerInit {
-  /**
-   * Should preemptively guarantee connections are above the low watermark
-   */
-  enabled?: boolean
-
   /**
    * The minimum number of connections to avoid pruning
    */
@@ -33,7 +28,6 @@ export interface AutoDiallerComponents {
 }
 
 const defaultOptions: Partial<AutoDiallerInit> = {
-  enabled: true,
   minConnections: 0,
   autoDialInterval: 10000
 }
@@ -58,19 +52,14 @@ export class AutoDialler implements Startable {
     log('options: %j', this.options)
   }
 
-  isStarted () {
+  isStarted (): boolean {
     return this.running
   }
 
   /**
    * Starts the auto dialer
    */
-  async start () {
-    if (!this.options.enabled) {
-      log('not enabled')
-      return
-    }
-
+  async start (): Promise<void> {
     this.running = true
 
     void this._autoDial().catch(err => {
@@ -83,12 +72,7 @@ export class AutoDialler implements Startable {
   /**
    * Stops the auto dialler
    */
-  async stop () {
-    if (!this.options.enabled) {
-      log('not enabled')
-      return
-    }
-
+  async stop (): Promise<void> {
     this.running = false
 
     if (this.autoDialTimeout != null) {
@@ -98,7 +82,7 @@ export class AutoDialler implements Startable {
     log('stopped')
   }
 
-  async _autoDial () {
+  async _autoDial (): Promise<void> {
     if (this.autoDialTimeout != null) {
       this.autoDialTimeout.clear()
     }

package/src/connection-manager/dialer/dial-request.ts

@@ -138,7 +138,7 @@ export class DialRequest {
           c.abort()
         }
       })
-      tokens.forEach(token => this.dialer.releaseToken(token)) // release tokens back to the dialer
+      tokens.forEach(token => { this.dialer.releaseToken(token) }) // release tokens back to the dialer
     }
   }
 }

package/src/connection-manager/dialer/index.ts

@@ -14,7 +14,7 @@ import {
   MAX_PER_PEER_DIALS,
   MAX_ADDRS_TO_DIAL
 } from '../../constants.js'
-import type { Connection, ConnectionGater } from '@libp2p/interface-connection'
+import type { Connection } from '@libp2p/interface-connection'
 import type { AbortOptions } from '@libp2p/interfaces'
 import type { Startable } from '@libp2p/interfaces/startable'
 import { isPeerId, PeerId } from '@libp2p/interface-peer-id'
@@ -23,6 +23,7 @@ import type { AddressSorter, PeerStore } from '@libp2p/interface-peer-store'
 import type { Metrics } from '@libp2p/interface-metrics'
 import type { Dialer } from '@libp2p/interface-connection-manager'
 import type { TransportManager } from '@libp2p/interface-transport'
+import type { ConnectionGater } from '@libp2p/interface-connection-gater'
 
 const log = logger('libp2p:dialer')
 
@@ -116,18 +117,18 @@ export class DefaultDialer implements Startable, Dialer {
     }
   }
 
-  isStarted () {
+  isStarted (): boolean {
     return this.started
   }
 
-  async start () {
+  async start (): Promise<void> {
     this.started = true
   }
 
   /**
    * Clears any pending dials
    */
-  async stop () {
+  async stop (): Promise<void> {
     this.started = false
 
     for (const dial of this.pendingDials.values()) {
@@ -163,7 +164,7 @@ export class DefaultDialer implements Startable, Dialer {
         await this.components.peerStore.addressBook.add(peerId, [multiaddr])
       }
 
-      if (await this.components.connectionGater.denyDialPeer(peerId)) {
+      if ((await this.components.connectionGater.denyDialPeer?.(peerId)) === true) {
         throw errCode(new Error('The dial request is blocked by gater.allowDialPeer'), codes.ERR_PEER_DIAL_INTERCEPTED)
       }
     }
@@ -298,9 +299,9 @@ export class DefaultDialer implements Startable, Dialer {
 
     return (await Promise.all(
       addresses.map(async address => {
-        const deny = await this.components.connectionGater.denyDialMultiaddr(peer, address.multiaddr)
+        const deny = await this.components.connectionGater.denyDialMultiaddr?.(peer, address.multiaddr)
 
-        if (deny) {
+        if (deny === true) {
           return false
         }
 
@@ -366,14 +367,14 @@ export class DefaultDialer implements Startable, Dialer {
     return pendingDial
   }
 
-  getTokens (num: number) {
+  getTokens (num: number): number[] {
     const total = Math.min(num, this.maxDialsPerPeer, this.tokens.length)
     const tokens = this.tokens.splice(0, total)
     log('%d tokens request, returning %d, %d remaining', num, total, this.tokens.length)
     return tokens
   }
 
-  releaseToken (token: number) {
+  releaseToken (token: number): void {
     // Guard against duplicate releases
     if (this.tokens.includes(token)) {
       return