libp2p 0.44.0 → 0.45.0-08d4c261

package/src/content-routing/index.ts

@@ -1,21 +1,18 @@
 import { CodeError } from '@libp2p/interfaces/errors'
+import merge from 'it-merge'
+import { pipe } from 'it-pipe'
 import { messages, codes } from '../errors.js'
 import {
   storeAddresses,
   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'
+import type { PeerInfo } from '@libp2p/interface-peer-info'
+import type { PeerStore } from '@libp2p/interface-peer-store'
 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 Promise.any(this.routers.map(async (router) => {
+      return router.get(key, options)
+    }))
   }
 }

package/src/content-routing/utils.ts

@@ -1,9 +1,9 @@
 import { CodeError } from '@libp2p/interfaces/errors'
 import filter from 'it-filter'
 import map from 'it-map'
-import type { Source } from 'it-stream-types'
 import type { PeerInfo } from '@libp2p/interface-peer-info'
 import type { PeerStore } from '@libp2p/interface-peer-store'
+import type { Source } from 'it-stream-types'
 
 /**
  * Store the multiaddrs from every peer in the passed peer store
@@ -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

@@ -1,34 +1,35 @@
-import { logger } from '@libp2p/logger'
+import { setMaxListeners } from 'events'
 import { CodeError } from '@libp2p/interfaces/errors'
-import { codes } from '../errors.js'
-import * as lp from 'it-length-prefixed'
-import { FetchRequest, FetchResponse } from './pb/proto.js'
-import { PROTOCOL_NAME, PROTOCOL_VERSION } from './constants.js'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { Startable } from '@libp2p/interfaces/startable'
-import type { Stream } from '@libp2p/interface-connection'
-import type { IncomingStreamData, Registrar } from '@libp2p/interface-registrar'
-import type { AbortOptions } from '@libp2p/interfaces'
+import { logger } from '@libp2p/logger'
 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 * as lp from 'it-length-prefixed'
+import { pipe } from 'it-pipe'
 import { fromString as uint8arrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8arrayToString } from 'uint8arrays/to-string'
+import { codes } from '../errors.js'
+import { PROTOCOL_NAME, PROTOCOL_VERSION } from './constants.js'
+import { FetchRequest, FetchResponse } from './pb/proto.js'
+import type { Stream } from '@libp2p/interface-connection'
 import type { ConnectionManager } from '@libp2p/interface-connection-manager'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import type { IncomingStreamData, Registrar } from '@libp2p/interface-registrar'
+import type { AbortOptions } from '@libp2p/interfaces'
+import type { Startable } from '@libp2p/interfaces/startable'
 
 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 {}
     }
 
@@ -163,10 +200,6 @@ export class FetchService implements Startable {
 
       return result ?? null
     } finally {
-      if (timeoutController != null) {
-        timeoutController.clear()
-      }
-
       if (stream != null) {
         stream.close()
       }
@@ -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)
+}

package/src/get-peer.ts

@@ -1,11 +1,11 @@
+import { isPeerId } from '@libp2p/interface-peer-id'
+import { CodeError } from '@libp2p/interfaces/errors'
+import { logger } from '@libp2p/logger'
 import { peerIdFromString } from '@libp2p/peer-id'
-import type { Multiaddr } from '@multiformats/multiaddr'
 import { isMultiaddr } from '@multiformats/multiaddr'
-import { CodeError } from '@libp2p/interfaces/errors'
 import { codes } from './errors.js'
-import { isPeerId } from '@libp2p/interface-peer-id'
 import type { PeerId } from '@libp2p/interface-peer-id'
-import { logger } from '@libp2p/logger'
+import type { Multiaddr } from '@multiformats/multiaddr'
 
 const log = logger('libp2p:get-peer')