libp2p 0.43.4 → 0.44.0-0d46c78f

package/src/connection-manager/utils.ts

@@ -0,0 +1,76 @@
+import { AbortOptions, multiaddr } from '@multiformats/multiaddr'
+import type { Multiaddr } from '@multiformats/multiaddr'
+import { logger } from '@libp2p/logger'
+import { ClearableSignal, anySignal } from 'any-signal'
+import { setMaxListeners } from 'events'
+
+const log = logger('libp2p:connection-manager:utils')
+
+/**
+ * Resolve multiaddr recursively
+ */
+export async function resolveMultiaddrs (ma: Multiaddr, options: AbortOptions): Promise<Multiaddr[]> {
+  // TODO: recursive logic should live in multiaddr once dns4/dns6 support is in place
+  // Now only supporting resolve for dnsaddr
+  const resolvableProto = ma.protoNames().includes('dnsaddr')
+
+  // Multiaddr is not resolvable? End recursion!
+  if (!resolvableProto) {
+    return [ma]
+  }
+
+  const resolvedMultiaddrs = await resolveRecord(ma, options)
+  const recursiveMultiaddrs = await Promise.all(resolvedMultiaddrs.map(async (nm) => {
+    return await resolveMultiaddrs(nm, options)
+  }))
+
+  const addrs = recursiveMultiaddrs.flat()
+  const output = addrs.reduce<Multiaddr[]>((array, newM) => {
+    if (array.find(m => m.equals(newM)) == null) {
+      array.push(newM)
+    }
+    return array
+  }, ([]))
+
+  log('resolved %s to', ma, output.map(ma => ma.toString()))
+
+  return output
+}
+
+/**
+ * Resolve a given multiaddr. If this fails, an empty array will be returned
+ */
+async function resolveRecord (ma: Multiaddr, options: AbortOptions): Promise<Multiaddr[]> {
+  try {
+    ma = multiaddr(ma.toString()) // Use current multiaddr module
+    const multiaddrs = await ma.resolve(options)
+    return multiaddrs
+  } catch (err) {
+    log.error(`multiaddr ${ma.toString()} could not be resolved`, err)
+    return []
+  }
+}
+
+export function combineSignals (...signals: Array<AbortSignal | undefined>): ClearableSignal {
+  const sigs: AbortSignal[] = []
+
+  for (const sig of signals) {
+    if (sig != null) {
+      try {
+        // fails on node < 15.4
+        setMaxListeners?.(Infinity, sig)
+      } catch { }
+      sigs.push(sig)
+    }
+  }
+
+  // let any signal abort the dial
+  const signal = anySignal(sigs)
+
+  try {
+    // fails on node < 15.4
+    setMaxListeners?.(Infinity, signal)
+  } catch {}
+
+  return signal
+}

package/src/content-routing/index.ts

@@ -5,7 +5,6 @@ import {
   uniquePeers,
   requirePeers
 } from './utils.js'
-import drain from 'it-drain'
 import merge from 'it-merge'
 import { pipe } from 'it-pipe'
 import type { ContentRouting } from '@libp2p/interface-content-routing'
@@ -13,9 +12,7 @@ import type { AbortOptions } from '@libp2p/interfaces'
 import type { Startable } from '@libp2p/interfaces/startable'
 import type { CID } from 'multiformats/cid'
 import type { PeerStore } from '@libp2p/interface-peer-store'
-import type { DualDHT } from '@libp2p/interface-dht'
 import type { PeerInfo } from '@libp2p/interface-peer-info'
-import type { PeerId } from '@libp2p/interface-peer-id'
 
 export interface CompoundContentRoutingInit {
   routers: ContentRouting[]
@@ -23,7 +20,6 @@ export interface CompoundContentRoutingInit {
 
 export interface CompoundContentRoutingComponents {
   peerStore: PeerStore
-  dht?: DualDHT
 }
 
 export class CompoundContentRouting implements ContentRouting, Startable {
@@ -54,7 +50,7 @@ export class CompoundContentRouting implements ContentRouting, Startable {
    */
   async * findProviders (key: CID, options: AbortOptions = {}): AsyncIterable<PeerInfo> {
     if (this.routers.length === 0) {
-      throw new CodeError('No content this.routers available', codes.ERR_NO_ROUTERS_AVAILABLE)
+      throw new CodeError('No content routers available', codes.ERR_NO_ROUTERS_AVAILABLE)
     }
 
     yield * pipe(
@@ -87,11 +83,9 @@ export class CompoundContentRouting implements ContentRouting, Startable {
       throw new CodeError(messages.NOT_STARTED_YET, codes.DHT_NOT_STARTED)
     }
 
-    const dht = this.components.dht
-
-    if (dht != null) {
-      await drain(dht.put(key, value, options))
-    }
+    await Promise.all(this.routers.map(async (router) => {
+      await router.put(key, value, options)
+    }))
   }
 
   /**
@@ -103,50 +97,8 @@ export class CompoundContentRouting implements ContentRouting, Startable {
       throw new CodeError(messages.NOT_STARTED_YET, codes.DHT_NOT_STARTED)
     }
 
-    const dht = this.components.dht
-
-    if (dht != null) {
-      for await (const event of dht.get(key, options)) {
-        if (event.name === 'VALUE') {
-          return event.value
-        }
-      }
-    }
-
-    throw new CodeError(messages.NOT_FOUND, codes.ERR_NOT_FOUND)
-  }
-
-  /**
-   * Get the `n` values to the given key without sorting
-   */
-  async * getMany (key: Uint8Array, nVals: number, options: AbortOptions): AsyncIterable<{ from: PeerId, val: Uint8Array }> {
-    if (!this.isStarted()) {
-      throw new CodeError(messages.NOT_STARTED_YET, codes.DHT_NOT_STARTED)
-    }
-
-    if (nVals == null || nVals === 0) {
-      return
-    }
-
-    let gotValues = 0
-    const dht = this.components.dht
-
-    if (dht != null) {
-      for await (const event of dht.get(key, options)) {
-        if (event.name === 'VALUE') {
-          yield { from: event.from, val: event.value }
-
-          gotValues++
-
-          if (gotValues === nVals) {
-            break
-          }
-        }
-      }
-    }
-
-    if (gotValues === 0) {
-      throw new CodeError(messages.NOT_FOUND, codes.ERR_NOT_FOUND)
-    }
+    return await Promise.any(this.routers.map(async (router) => {
+      return await router.get(key, options)
+    }))
   }
 }

package/src/content-routing/utils.ts

@@ -11,7 +11,9 @@ import type { PeerStore } from '@libp2p/interface-peer-store'
 export async function * storeAddresses (source: Source<PeerInfo>, peerStore: PeerStore): AsyncIterable<PeerInfo> {
   yield * map(source, async (peer) => {
     // ensure we have the addresses for a given peer
-    await peerStore.addressBook.add(peer.id, peer.multiaddrs)
+    await peerStore.merge(peer.id, {
+      multiaddrs: peer.multiaddrs
+    })
 
     return peer
   })

package/src/fetch/index.ts

@@ -12,7 +12,6 @@ import type { AbortOptions } from '@libp2p/interfaces'
 import { abortableDuplex } from 'abortable-iterator'
 import { pipe } from 'it-pipe'
 import first from 'it-first'
-import { TimeoutController } from 'timeout-abort-controller'
 import { setMaxListeners } from 'events'
 import { fromString as uint8arrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8arrayToString } from 'uint8arrays/to-string'
@@ -20,15 +19,17 @@ import type { ConnectionManager } from '@libp2p/interface-connection-manager'
 
 const log = logger('libp2p:fetch')
 
+const DEFAULT_TIMEOUT = 10000
+
 export interface FetchServiceInit {
-  protocolPrefix: string
-  maxInboundStreams: number
-  maxOutboundStreams: number
+  protocolPrefix?: string
+  maxInboundStreams?: number
+  maxOutboundStreams?: number
 
   /**
    * How long we should wait for a remote peer to send any data
    */
-  timeout: number
+  timeout?: number
 }
 
 export interface HandleMessageOptions {
@@ -45,13 +46,51 @@ export interface FetchServiceComponents {
   connectionManager: ConnectionManager
 }
 
+export interface FetchService {
+  /**
+   * The protocol name used by this fetch service
+   */
+  protocol: string
+
+  /**
+   * Sends a request to fetch the value associated with the given key from the given peer
+   */
+  fetch: (peer: PeerId, key: string, options?: AbortOptions) => Promise<Uint8Array | null>
+
+  /**
+   * Registers a new lookup callback that can map keys to values, for a given set of keys that
+   * share the same prefix
+   *
+   * @example
+   *
+   * ```js
+   * // ...
+   * libp2p.fetchService.registerLookupFunction('/prefix', (key) => { ... })
+   * ```
+   */
+  registerLookupFunction: (prefix: string, lookup: LookupFunction) => void
+
+  /**
+   * Registers a new lookup callback that can map keys to values, for a given set of keys that
+   * share the same prefix.
+   *
+   * @example
+   *
+   * ```js
+   * // ...
+   * libp2p.fetchService.unregisterLookupFunction('/prefix')
+   * ```
+   */
+  unregisterLookupFunction: (prefix: string, lookup?: LookupFunction) => void
+}
+
 /**
  * A simple libp2p protocol for requesting a value corresponding to a key from a peer.
  * Developers can register one or more lookup function for retrieving the value corresponding to
  * a given key.  Each lookup function must act on a distinct part of the overall key space, defined
  * by a fixed prefix that all keys that should be routed to that lookup function will start with.
  */
-export class FetchService implements Startable {
+class DefaultFetchService implements Startable, FetchService {
   public readonly protocol: string
   private readonly components: FetchServiceComponents
   private readonly lookupFunctions: Map<string, LookupFunction>
@@ -99,19 +138,17 @@ export class FetchService implements Startable {
     log('dialing %s to %p', this.protocol, peer)
 
     const connection = await this.components.connectionManager.openConnection(peer, options)
-    let timeoutController
     let signal = options.signal
     let stream: Stream | undefined
 
     // create a timeout if no abort signal passed
     if (signal == null) {
       log('using default timeout of %d ms', this.init.timeout)
-      timeoutController = new TimeoutController(this.init.timeout)
-      signal = timeoutController.signal
+      signal = AbortSignal.timeout(this.init.timeout ?? DEFAULT_TIMEOUT)
 
       try {
         // fails on node < 15.4
-        setMaxListeners?.(Infinity, timeoutController.signal)
+        setMaxListeners?.(Infinity, signal)
       } catch {}
     }
 
@@ -127,9 +164,9 @@ export class FetchService implements Startable {
 
       const result = await pipe(
         [FetchRequest.encode({ identifier: key })],
-        lp.encode(),
+        (source) => lp.encode(source),
         source,
-        lp.decode(),
+        (source) => lp.decode(source),
         async function (source) {
           const buf = await first(source)
 
@@ -163,10 +200,6 @@ export class FetchService implements Startable {
 
       return result ?? null
     } finally {
-      if (timeoutController != null) {
-        timeoutController.clear()
-      }
-
       if (stream != null) {
         stream.close()
       }
@@ -184,7 +217,7 @@ export class FetchService implements Startable {
 
     await pipe(
       stream,
-      lp.decode(),
+      (source) => lp.decode(source),
       async function * (source) {
         const buf = await first(source)
 
@@ -215,7 +248,7 @@ export class FetchService implements Startable {
 
         yield FetchResponse.encode(response)
       },
-      lp.encode(),
+      (source) => lp.encode(source),
       stream
     )
   }
@@ -274,3 +307,7 @@ export class FetchService implements Startable {
     this.lookupFunctions.delete(prefix)
   }
 }
+
+export function fetchService (init: FetchServiceInit = {}): (components: FetchServiceComponents) => FetchService {
+  return (components) => new DefaultFetchService(components, init)
+}