libp2p 0.44.0 → 0.45.0

package/src/upgrader.ts

@@ -3,18 +3,17 @@ import { CodeError } from '@libp2p/interfaces/errors'
 import * as mss from '@libp2p/multistream-select'
 import { codes } from './errors.js'
 import { createConnection } from './connection/index.js'
-import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
+import type { EventEmitter } from '@libp2p/interfaces/events'
 import { peerIdFromString } from '@libp2p/peer-id'
 import type { MultiaddrConnection, Connection, Stream, ConnectionProtector } from '@libp2p/interface-connection'
 import type { ConnectionEncrypter, SecuredConnection } from '@libp2p/interface-connection-encrypter'
 import type { StreamMuxer, StreamMuxerFactory } from '@libp2p/interface-stream-muxer'
 import type { PeerId } from '@libp2p/interface-peer-id'
-import type { Upgrader, UpgraderEvents, UpgraderOptions } from '@libp2p/interface-transport'
-import type { Duplex } from 'it-stream-types'
+import type { Upgrader, UpgraderOptions } from '@libp2p/interface-transport'
+import type { Duplex, Source } from 'it-stream-types'
 import type { AbortOptions } from '@libp2p/interfaces'
 import type { Registrar } from '@libp2p/interface-registrar'
 import { DEFAULT_MAX_INBOUND_STREAMS, DEFAULT_MAX_OUTBOUND_STREAMS } from './registrar.js'
-import { TimeoutController } from 'timeout-abort-controller'
 import { abortableDuplex } from 'abortable-iterator'
 import { setMaxListeners } from 'events'
 import type { Metrics } from '@libp2p/interface-metrics'
@@ -22,14 +21,16 @@ import type { ConnectionManager } from '@libp2p/interface-connection-manager'
 import type { PeerStore } from '@libp2p/interface-peer-store'
 import type { ConnectionGater } from '@libp2p/interface-connection-gater'
 import { INBOUND_UPGRADE_TIMEOUT } from './connection-manager/constants.js'
+import { anySignal } from 'any-signal'
+import type { Libp2pEvents } from '@libp2p/interface-libp2p'
 
 const log = logger('libp2p:upgrader')
 
-interface CreateConectionOptions {
+interface CreateConnectionOptions {
   cryptoProtocol: string
   direction: 'inbound' | 'outbound'
   maConn: MultiaddrConnection
-  upgradedConn: Duplex<Uint8Array>
+  upgradedConn: Duplex<AsyncGenerator<Uint8Array>, Source<Uint8Array>, Promise<void>>
   remotePeer: PeerId
   muxerFactory?: StreamMuxerFactory
 }
@@ -72,7 +73,6 @@ function findIncomingStreamLimit (protocol: string, registrar: Registrar): numbe
 function findOutgoingStreamLimit (protocol: string, registrar: Registrar): number | undefined {
   try {
     const { options } = registrar.getHandler(protocol)
-
     return options.maxOutboundStreams
   } catch (err: any) {
     if (err.code !== codes.ERR_NO_HANDLER_FOR_PROTOCOL) {
@@ -103,17 +103,21 @@ export interface DefaultUpgraderComponents {
   connectionProtector?: ConnectionProtector
   registrar: Registrar
   peerStore: PeerStore
+  events: EventEmitter<Libp2pEvents>
 }
 
-export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upgrader {
+type EncryptedConn = Duplex<AsyncGenerator<Uint8Array, any, unknown>, Source<Uint8Array>, Promise<void>>
+
+type ConnectionDeniedType = keyof Pick<ConnectionGater, 'denyOutboundConnection' | 'denyInboundEncryptedConnection' | 'denyOutboundEncryptedConnection' | 'denyInboundUpgradedConnection' | 'denyOutboundUpgradedConnection'>
+
+export class DefaultUpgrader implements Upgrader {
   private readonly components: DefaultUpgraderComponents
   private readonly connectionEncryption: Map<string, ConnectionEncrypter>
   private readonly muxers: Map<string, StreamMuxerFactory>
   private readonly inboundUpgradeTimeout: number
+  private readonly events: EventEmitter<Libp2pEvents>
 
   constructor (components: DefaultUpgraderComponents, init: UpgraderInit) {
-    super()
-
     this.components = components
     this.connectionEncryption = new Map()
 
@@ -128,6 +132,17 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
     })
 
     this.inboundUpgradeTimeout = init.inboundUpgradeTimeout ?? INBOUND_UPGRADE_TIMEOUT
+    this.events = components.events
+  }
+
+  async shouldBlockConnection (remotePeer: PeerId, maConn: MultiaddrConnection, connectionType: ConnectionDeniedType): Promise<void> {
+    const connectionGater = this.components.connectionGater[connectionType]
+
+    if (connectionGater !== undefined) {
+      if (await connectionGater(remotePeer, maConn)) {
+        throw new CodeError(`The multiaddr connection is blocked by gater.${connectionType}`, codes.ERR_CONNECTION_INTERCEPTED)
+      }
+    }
   }
 
   /**
@@ -140,21 +155,21 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
       throw new CodeError('connection denied', codes.ERR_CONNECTION_DENIED)
     }
 
-    let encryptedConn
+    let encryptedConn: EncryptedConn
     let remotePeer
-    let upgradedConn: Duplex<Uint8Array>
+    let upgradedConn: Duplex<AsyncGenerator<Uint8Array>, Source<Uint8Array>, Promise<void>>
     let muxerFactory: StreamMuxerFactory | undefined
     let cryptoProtocol
 
-    const timeoutController = new TimeoutController(this.inboundUpgradeTimeout)
+    const signal = anySignal([AbortSignal.timeout(this.inboundUpgradeTimeout)])
 
     try {
       // fails on node < 15.4
-      setMaxListeners?.(Infinity, timeoutController.signal)
+      setMaxListeners?.(Infinity, signal)
     } catch { }
 
     try {
-      const abortableStream = abortableDuplex(maConn, timeoutController.signal)
+      const abortableStream = abortableDuplex(maConn, signal)
       maConn.source = abortableStream.source
       maConn.sink = abortableStream.sink
 
@@ -188,12 +203,12 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
             protocol: cryptoProtocol
           } = await this._encryptInbound(protectedConn))
 
-          if ((await this.components.connectionGater.denyInboundEncryptedConnection?.(remotePeer, {
+          const maConn: MultiaddrConnection = {
             ...protectedConn,
             ...encryptedConn
-          })) === true) {
-            throw new CodeError('The multiaddr connection is blocked by gater.acceptEncryptedConnection', codes.ERR_CONNECTION_INTERCEPTED)
           }
+
+          await this.shouldBlockConnection(remotePeer, maConn, 'denyInboundEncryptedConnection')
         } else {
           const idStr = maConn.remoteAddr.getPeerId()
 
@@ -224,12 +239,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
         throw err
       }
 
-      if ((await this.components.connectionGater.denyInboundUpgradedConnection?.(remotePeer, {
-        ...protectedConn,
-        ...encryptedConn
-      })) === true) {
-        throw new CodeError('The multiaddr connection is blocked by gater.acceptEncryptedConnection', codes.ERR_CONNECTION_INTERCEPTED)
-      }
+      await this.shouldBlockConnection(remotePeer, maConn, 'denyInboundUpgradedConnection')
 
       log('Successfully upgraded inbound connection')
 
@@ -243,7 +253,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
       })
     } finally {
       this.components.connectionManager.afterUpgradeInbound()
-      timeoutController.clear()
+      signal.clear()
     }
   }
 
@@ -257,14 +267,12 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
     if (idStr != null) {
       remotePeerId = peerIdFromString(idStr)
 
-      if ((await this.components.connectionGater.denyOutboundConnection?.(remotePeerId, maConn)) === true) {
-        throw new CodeError('The multiaddr connection is blocked by connectionGater.denyOutboundConnection', codes.ERR_CONNECTION_INTERCEPTED)
-      }
+      await this.shouldBlockConnection(remotePeerId, maConn, 'denyOutboundConnection')
     }
 
     let encryptedConn
     let remotePeer: PeerId
-    let upgradedConn
+    let upgradedConn: Duplex<AsyncGenerator<Uint8Array>, Source<Uint8Array>, Promise<void>>
     let cryptoProtocol
     let muxerFactory
 
@@ -295,12 +303,12 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
           protocol: cryptoProtocol
         } = await this._encryptOutbound(protectedConn, remotePeerId))
 
-        if ((await this.components.connectionGater.denyOutboundEncryptedConnection?.(remotePeer, {
+        const maConn: MultiaddrConnection = {
           ...protectedConn,
           ...encryptedConn
-        })) === true) {
-          throw new CodeError('The multiaddr connection is blocked by gater.acceptEncryptedConnection', codes.ERR_CONNECTION_INTERCEPTED)
         }
+
+        await this.shouldBlockConnection(remotePeer, maConn, 'denyOutboundEncryptedConnection')
       } else {
         if (remotePeerId == null) {
           throw new CodeError('Encryption was skipped but no peer id was passed', codes.ERR_INVALID_PEER)
@@ -328,12 +336,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
       throw err
     }
 
-    if ((await this.components.connectionGater.denyOutboundUpgradedConnection?.(remotePeer, {
-      ...protectedConn,
-      ...encryptedConn
-    })) === true) {
-      throw new CodeError('The multiaddr connection is blocked by gater.acceptEncryptedConnection', codes.ERR_CONNECTION_INTERCEPTED)
-    }
+    await this.shouldBlockConnection(remotePeer, maConn, 'denyOutboundUpgradedConnection')
 
     log('Successfully upgraded outbound connection')
 
@@ -350,7 +353,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
   /**
    * A convenience method for generating a new `Connection`
    */
-  _createConnection (opts: CreateConectionOptions): Connection {
+  _createConnection (opts: CreateConnectionOptions): Connection {
     const {
       cryptoProtocol,
       direction,
@@ -388,9 +391,10 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
               const streamCount = countStreams(protocol, 'inbound', connection)
 
               if (streamCount === incomingLimit) {
-                muxedStream.abort(new CodeError(`Too many inbound protocol streams for protocol "${protocol}" - limit ${incomingLimit}`, codes.ERR_TOO_MANY_INBOUND_PROTOCOL_STREAMS))
+                const err = new CodeError(`Too many inbound protocol streams for protocol "${protocol}" - limit ${incomingLimit}`, codes.ERR_TOO_MANY_INBOUND_PROTOCOL_STREAMS)
+                muxedStream.abort(err)
 
-                return
+                throw err
               }
 
               // after the handshake the returned stream can have early data so override
@@ -401,7 +405,9 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
 
               // If a protocol stream has been successfully negotiated and is to be passed to the application,
               // the peerstore should ensure that the peer is registered with that protocol
-              this.components.peerStore.protoBook.add(remotePeer, [protocol]).catch(err => { log.error(err) })
+              await this.components.peerStore.merge(remotePeer, {
+                protocols: [protocol]
+              })
 
               connection.addStream(muxedStream)
               this.components.metrics?.trackProtocolStream(muxedStream, connection)
@@ -429,18 +435,16 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
 
         log('%s: starting new stream on %s', direction, protocols)
         const muxedStream = await muxer.newStream()
-        let controller: TimeoutController | undefined
 
         try {
           if (options.signal == null) {
             log('No abort signal was passed while trying to negotiate protocols %s falling back to default timeout', protocols)
 
-            controller = new TimeoutController(30000)
-            options.signal = controller.signal
+            options.signal = AbortSignal.timeout(30000)
 
             try {
               // fails on node < 15.4
-              setMaxListeners?.(Infinity, controller.signal)
+              setMaxListeners?.(Infinity, options.signal)
             } catch { }
           }
 
@@ -458,7 +462,9 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
 
           // If a protocol stream has been successfully negotiated and is to be passed to the application,
           // the peerstore should ensure that the peer is registered with that protocol
-          this.components.peerStore.protoBook.add(remotePeer, [protocol]).catch(err => { log.error(err) })
+          await this.components.peerStore.merge(remotePeer, {
+            protocols: [protocol]
+          })
 
           // after the handshake the returned stream can have early data so override
           // the souce/sink
@@ -481,10 +487,6 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
           }
 
           throw new CodeError(String(err), codes.ERR_UNSUPPORTED_PROTOCOL)
-        } finally {
-          if (controller != null) {
-            controller.clear()
-          }
         }
       }
 
@@ -510,9 +512,9 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
             } catch (err: any) {
               log.error(err)
             } finally {
-              this.dispatchEvent(new CustomEvent<Connection>('connectionEnd', {
+              this.events.safeDispatchEvent('connection:close', {
                 detail: connection
-              }))
+              })
             }
           })().catch(err => {
             log.error(err)
@@ -550,9 +552,9 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
       }
     })
 
-    this.dispatchEvent(new CustomEvent<Connection>('connection', {
+    this.events.safeDispatchEvent('connection:open', {
       detail: connection
-    }))
+    })
 
     return connection
   }
@@ -570,7 +572,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
   /**
    * Attempts to encrypt the incoming `connection` with the provided `cryptos`
    */
-  async _encryptInbound (connection: Duplex<Uint8Array>): Promise<CryptoResult> {
+  async _encryptInbound (connection: Duplex<AsyncGenerator<Uint8Array>, Source<Uint8Array>>): Promise<CryptoResult> {
     const protocols = Array.from(this.connectionEncryption.keys())
     log('handling inbound crypto protocol selection', protocols)
 
@@ -628,7 +630,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
    * Selects one of the given muxers via multistream-select. That
    * muxer will be used for all future streams on the connection.
    */
-  async _multiplexOutbound (connection: MultiaddrConnection, muxers: Map<string, StreamMuxerFactory>): Promise<{ stream: Duplex<Uint8Array>, muxerFactory?: StreamMuxerFactory }> {
+  async _multiplexOutbound (connection: MultiaddrConnection, muxers: Map<string, StreamMuxerFactory>): Promise<{ stream: Duplex<AsyncGenerator<Uint8Array>, Source<Uint8Array>, Promise<void>>, muxerFactory?: StreamMuxerFactory }> {
     const protocols = Array.from(muxers.keys())
     log('outbound selecting muxer %s', protocols)
     try {
@@ -637,6 +639,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
       })
       log('%s selected as muxer protocol', protocol)
       const muxerFactory = muxers.get(protocol)
+
       return { stream, muxerFactory }
     } catch (err: any) {
       log.error('error multiplexing outbound stream', err)
@@ -648,7 +651,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
    * Registers support for one of the given muxers via multistream-select. The
    * selected muxer will be used for all future streams on the connection.
    */
-  async _multiplexInbound (connection: MultiaddrConnection, muxers: Map<string, StreamMuxerFactory>): Promise<{ stream: Duplex<Uint8Array>, muxerFactory?: StreamMuxerFactory }> {
+  async _multiplexInbound (connection: MultiaddrConnection, muxers: Map<string, StreamMuxerFactory>): Promise<{ stream: Duplex<AsyncGenerator<Uint8Array>, Source<Uint8Array>, Promise<void>>, muxerFactory?: StreamMuxerFactory }> {
     const protocols = Array.from(muxers.keys())
     log('inbound handling muxers %s', protocols)
     try {
@@ -656,6 +659,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
         writeBytes: true
       })
       const muxerFactory = muxers.get(protocol)
+
       return { stream, muxerFactory }
     } catch (err: any) {
       log.error('error multiplexing inbound stream', err)

package/src/{nat-manager.ts → upnp-nat/index.ts}

@@ -3,16 +3,16 @@ import { logger } from '@libp2p/logger'
 import { fromNodeAddress } from '@multiformats/multiaddr'
 import { isBrowser } from 'wherearewe'
 import isPrivateIp from 'private-ip'
-import * as pkg from './version.js'
+import * as pkg from '../version.js'
 import { CodeError } from '@libp2p/interfaces/errors'
-import { codes } from './errors.js'
+import { codes } from '../errors.js'
 import { isLoopback } from '@libp2p/utils/multiaddr/is-loopback'
 import type { Startable } from '@libp2p/interfaces/startable'
 import type { TransportManager } from '@libp2p/interface-transport'
 import type { PeerId } from '@libp2p/interface-peer-id'
 import type { AddressManager } from '@libp2p/interface-address-manager'
 
-const log = logger('libp2p:nat')
+const log = logger('libp2p:upnp-nat')
 const DEFAULT_TTL = 7200
 
 function highPort (min = 1024, max = 65535): number {
@@ -26,12 +26,7 @@ export interface PMPOptions {
   enabled?: boolean
 }
 
-export interface NatManagerInit {
-  /**
-   * Whether to enable the NAT manager
-   */
-  enabled: boolean
-
+export interface UPnPNATInit {
   /**
    * Pass a value to use instead of auto-detection
    */
@@ -55,7 +50,7 @@ export interface NatManagerInit {
   /**
    * Whether to automatically refresh UPnP port mappings when their TTL is reached
    */
-  keepAlive: boolean
+  keepAlive?: boolean
 
   /**
    * Pass a value to use instead of auto-detection
@@ -63,15 +58,14 @@ export interface NatManagerInit {
   gateway?: string
 }
 
-export interface NatManagerComponents {
+export interface UPnPNATComponents {
   peerId: PeerId
   transportManager: TransportManager
   addressManager: AddressManager
 }
 
-export class NatManager implements Startable {
-  private readonly components: NatManagerComponents
-  private readonly enabled: boolean
+class UPnPNAT implements Startable {
+  private readonly components: UPnPNATComponents
   private readonly externalAddress?: string
   private readonly localAddress?: string
   private readonly description: string
@@ -81,11 +75,10 @@ export class NatManager implements Startable {
   private started: boolean
   private client?: NatAPI
 
-  constructor (components: NatManagerComponents, init: NatManagerInit) {
+  constructor (components: UPnPNATComponents, init: UPnPNATInit) {
     this.components = components
 
     this.started = false
-    this.enabled = init.enabled
     this.externalAddress = init.externalAddress
     this.localAddress = init.localAddress
     this.description = init.description ?? `${pkg.name}@${pkg.version} ${this.components.peerId.toString()}`
@@ -112,7 +105,7 @@ export class NatManager implements Startable {
    * Run after start to ensure the transport manager has all addresses configured.
    */
   afterStart (): void {
-    if (isBrowser || !this.enabled || this.started) {
+    if (isBrowser || this.started) {
       return
     }
 
@@ -211,3 +204,9 @@ export class NatManager implements Startable {
     }
   }
 }
+
+export function uPnPNATService (init: UPnPNATInit = {}): (components: UPnPNATComponents) => {} {
+  return (components: UPnPNATComponents) => {
+    return new UPnPNAT(components, init)
+  }
+}

package/src/version.ts

@@ -1,2 +1,2 @@
-export const version = '0.44.0'
+export const version = '0.45.0'
 export const name = 'libp2p'

package/dist/src/dht/dht-content-routing.d.ts

@@ -1,17 +0,0 @@
-import type { DHT } from '@libp2p/interface-dht';
-import type { ContentRouting } from '@libp2p/interface-content-routing';
-import type { CID } from 'multiformats/cid';
-import type { AbortOptions } from '@libp2p/interfaces';
-import type { PeerInfo } from '@libp2p/interface-peer-info';
-/**
- * Wrapper class to convert events into returned values
- */
-export declare class DHTContentRouting implements ContentRouting {
-    private readonly dht;
-    constructor(dht: DHT);
-    provide(cid: CID): Promise<void>;
-    findProviders(cid: CID, options?: AbortOptions): AsyncGenerator<PeerInfo, void, undefined>;
-    put(key: Uint8Array, value: Uint8Array, options?: AbortOptions): Promise<void>;
-    get(key: Uint8Array, options?: AbortOptions): Promise<Uint8Array>;
-}
-//# sourceMappingURL=dht-content-routing.d.ts.map

package/dist/src/dht/dht-content-routing.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dht-content-routing.d.ts","sourceRoot":"","sources":["../../../src/dht/dht-content-routing.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,uBAAuB,CAAA;AAChD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAA;AACvE,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AAC3C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AACtD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAA;AAE3D;;GAEG;AACH,qBAAa,iBAAkB,YAAW,cAAc;IACtD,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAK;gBAEZ,GAAG,EAAE,GAAG;IAIf,OAAO,CAAE,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;IAI/B,aAAa,CAAE,GAAG,EAAE,GAAG,EAAE,OAAO,GAAE,YAAiB,GAAG,cAAc,CAAC,QAAQ,EAAE,IAAI,EAAE,SAAS,CAAC;IAQjG,GAAG,CAAE,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAI/E,GAAG,CAAE,GAAG,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,UAAU,CAAC;CASzE"}

package/dist/src/dht/dht-content-routing.js

@@ -1,32 +0,0 @@
-import drain from 'it-drain';
-import { CodeError } from '@libp2p/interfaces/errors';
-/**
- * Wrapper class to convert events into returned values
- */
-export class DHTContentRouting {
-    constructor(dht) {
-        this.dht = dht;
-    }
-    async provide(cid) {
-        await drain(this.dht.provide(cid));
-    }
-    async *findProviders(cid, options = {}) {
-        for await (const event of this.dht.findProviders(cid, options)) {
-            if (event.name === 'PROVIDER') {
-                yield* event.providers;
-            }
-        }
-    }
-    async put(key, value, options) {
-        await drain(this.dht.put(key, value, options));
-    }
-    async get(key, options) {
-        for await (const event of this.dht.get(key, options)) {
-            if (event.name === 'VALUE') {
-                return event.value;
-            }
-        }
-        throw new CodeError('Not found', 'ERR_NOT_FOUND');
-    }
-}
-//# sourceMappingURL=dht-content-routing.js.map

package/dist/src/dht/dht-content-routing.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"dht-content-routing.js","sourceRoot":"","sources":["../../../src/dht/dht-content-routing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,UAAU,CAAA;AAC5B,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAA;AAOrD;;GAEG;AACH,MAAM,OAAO,iBAAiB;IAG5B,YAAa,GAAQ;QACnB,IAAI,CAAC,GAAG,GAAG,GAAG,CAAA;IAChB,CAAC;IAED,KAAK,CAAC,OAAO,CAAE,GAAQ;QACrB,MAAM,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAA;IACpC,CAAC;IAED,KAAK,CAAC,CAAE,aAAa,CAAE,GAAQ,EAAE,UAAwB,EAAE;QACzD,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,GAAG,EAAE,OAAO,CAAC,EAAE;YAC9D,IAAI,KAAK,CAAC,IAAI,KAAK,UAAU,EAAE;gBAC7B,KAAM,CAAC,CAAC,KAAK,CAAC,SAAS,CAAA;aACxB;SACF;IACH,CAAC;IAED,KAAK,CAAC,GAAG,CAAE,GAAe,EAAE,KAAiB,EAAE,OAAsB;QACnE,MAAM,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC,CAAA;IAChD,CAAC;IAED,KAAK,CAAC,GAAG,CAAE,GAAe,EAAE,OAAsB;QAChD,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,OAAO,CAAC,EAAE;YACpD,IAAI,KAAK,CAAC,IAAI,KAAK,OAAO,EAAE;gBAC1B,OAAO,KAAK,CAAC,KAAK,CAAA;aACnB;SACF;QAED,MAAM,IAAI,SAAS,CAAC,WAAW,EAAE,eAAe,CAAC,CAAA;IACnD,CAAC;CACF"}

package/dist/src/dht/dht-peer-routing.d.ts

@@ -1,15 +0,0 @@
-import type { PeerRouting } from '@libp2p/interface-peer-routing';
-import type { DHT } from '@libp2p/interface-dht';
-import type { PeerId } from '@libp2p/interface-peer-id';
-import type { AbortOptions } from '@libp2p/interfaces';
-import type { PeerInfo } from '@libp2p/interface-peer-info';
-/**
- * Wrapper class to convert events into returned values
- */
-export declare class DHTPeerRouting implements PeerRouting {
-    private readonly dht;
-    constructor(dht: DHT);
-    findPeer(peerId: PeerId, options?: AbortOptions): Promise<PeerInfo>;
-    getClosestPeers(key: Uint8Array, options?: AbortOptions): AsyncIterable<PeerInfo>;
-}
-//# sourceMappingURL=dht-peer-routing.d.ts.map

package/dist/src/dht/dht-peer-routing.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dht-peer-routing.d.ts","sourceRoot":"","sources":["../../../src/dht/dht-peer-routing.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAA;AACjE,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,uBAAuB,CAAA;AAChD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAA;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AACtD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAA;AAE3D;;GAEG;AACH,qBAAa,cAAe,YAAW,WAAW;IAChD,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAK;gBAEZ,GAAG,EAAE,GAAG;IAIf,QAAQ,CAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB,GAAG,OAAO,CAAC,QAAQ,CAAC;IAUtE,eAAe,CAAE,GAAG,EAAE,UAAU,EAAE,OAAO,GAAE,YAAiB,GAAG,aAAa,CAAC,QAAQ,CAAC;CAO/F"}

package/dist/src/dht/dht-peer-routing.js

@@ -1,26 +0,0 @@
-import { CodeError } from '@libp2p/interfaces/errors';
-import { messages, codes } from '../errors.js';
-/**
- * Wrapper class to convert events into returned values
- */
-export class DHTPeerRouting {
-    constructor(dht) {
-        this.dht = dht;
-    }
-    async findPeer(peerId, options = {}) {
-        for await (const event of this.dht.findPeer(peerId, options)) {
-            if (event.name === 'FINAL_PEER') {
-                return event.peer;
-            }
-        }
-        throw new CodeError(messages.NOT_FOUND, codes.ERR_NOT_FOUND);
-    }
-    async *getClosestPeers(key, options = {}) {
-        for await (const event of this.dht.getClosestPeers(key, options)) {
-            if (event.name === 'FINAL_PEER') {
-                yield event.peer;
-            }
-        }
-    }
-}
-//# sourceMappingURL=dht-peer-routing.js.map

package/dist/src/dht/dht-peer-routing.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"dht-peer-routing.js","sourceRoot":"","sources":["../../../src/dht/dht-peer-routing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAA;AACrD,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,cAAc,CAAA;AAO9C;;GAEG;AACH,MAAM,OAAO,cAAc;IAGzB,YAAa,GAAQ;QACnB,IAAI,CAAC,GAAG,GAAG,GAAG,CAAA;IAChB,CAAC;IAED,KAAK,CAAC,QAAQ,CAAE,MAAc,EAAE,UAAwB,EAAE;QACxD,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE;YAC5D,IAAI,KAAK,CAAC,IAAI,KAAK,YAAY,EAAE;gBAC/B,OAAO,KAAK,CAAC,IAAI,CAAA;aAClB;SACF;QAED,MAAM,IAAI,SAAS,CAAC,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC,aAAa,CAAC,CAAA;IAC9D,CAAC;IAED,KAAK,CAAC,CAAE,eAAe,CAAE,GAAe,EAAE,UAAwB,EAAE;QAClE,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,eAAe,CAAC,GAAG,EAAE,OAAO,CAAC,EAAE;YAChE,IAAI,KAAK,CAAC,IAAI,KAAK,YAAY,EAAE;gBAC/B,MAAM,KAAK,CAAC,IAAI,CAAA;aACjB;SACF;IACH,CAAC;CACF"}

package/dist/src/dht/dummy-dht.d.ts

@@ -1,20 +0,0 @@
-import type { DualDHT, QueryEvent, SingleDHT } from '@libp2p/interface-dht';
-import type { PeerDiscoveryEvents } from '@libp2p/interface-peer-discovery';
-import { EventEmitter } from '@libp2p/interfaces/events';
-import { symbol } from '@libp2p/interface-peer-discovery';
-export declare class DummyDHT extends EventEmitter<PeerDiscoveryEvents> implements DualDHT {
-    get [symbol](): true;
-    get [Symbol.toStringTag](): '@libp2p/dummy-dht';
-    get wan(): SingleDHT;
-    get lan(): SingleDHT;
-    get(): AsyncIterable<QueryEvent>;
-    findProviders(): AsyncIterable<QueryEvent>;
-    findPeer(): AsyncIterable<QueryEvent>;
-    getClosestPeers(): AsyncIterable<QueryEvent>;
-    provide(): AsyncIterable<QueryEvent>;
-    put(): AsyncIterable<QueryEvent>;
-    getMode(): Promise<'client' | 'server'>;
-    setMode(): Promise<void>;
-    refreshRoutingTable(): Promise<void>;
-}
-//# sourceMappingURL=dummy-dht.d.ts.map

package/dist/src/dht/dummy-dht.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dummy-dht.d.ts","sourceRoot":"","sources":["../../../src/dht/dummy-dht.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AAC3E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAA;AAG3E,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AACxD,OAAO,EAAE,MAAM,EAAE,MAAM,kCAAkC,CAAA;AAEzD,qBAAa,QAAS,SAAQ,YAAY,CAAC,mBAAmB,CAAE,YAAW,OAAO;IAChF,IAAI,CAAC,MAAM,CAAC,IAAK,IAAI,CAEpB;IAED,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAK,mBAAmB,CAE/C;IAED,IAAI,GAAG,IAAK,SAAS,CAEpB;IAED,IAAI,GAAG,IAAK,SAAS,CAEpB;IAED,GAAG,IAAK,aAAa,CAAC,UAAU,CAAC;IAIjC,aAAa,IAAK,aAAa,CAAC,UAAU,CAAC;IAI3C,QAAQ,IAAK,aAAa,CAAC,UAAU,CAAC;IAItC,eAAe,IAAK,aAAa,CAAC,UAAU,CAAC;IAI7C,OAAO,IAAK,aAAa,CAAC,UAAU,CAAC;IAIrC,GAAG,IAAK,aAAa,CAAC,UAAU,CAAC;IAI3B,OAAO,IAAK,OAAO,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAIxC,OAAO,IAAK,OAAO,CAAC,IAAI,CAAC;IAIzB,mBAAmB,IAAK,OAAO,CAAC,IAAI,CAAC;CAG5C"}

package/dist/src/dht/dummy-dht.js

@@ -1,46 +0,0 @@
-import { CodeError } from '@libp2p/interfaces/errors';
-import { messages, codes } from '../errors.js';
-import { EventEmitter } from '@libp2p/interfaces/events';
-import { symbol } from '@libp2p/interface-peer-discovery';
-export class DummyDHT extends EventEmitter {
-    get [symbol]() {
-        return true;
-    }
-    get [Symbol.toStringTag]() {
-        return '@libp2p/dummy-dht';
-    }
-    get wan() {
-        throw new CodeError(messages.DHT_DISABLED, codes.DHT_DISABLED);
-    }
-    get lan() {
-        throw new CodeError(messages.DHT_DISABLED, codes.DHT_DISABLED);
-    }
-    get() {
-        throw new CodeError(messages.DHT_DISABLED, codes.DHT_DISABLED);
-    }
-    findProviders() {
-        throw new CodeError(messages.DHT_DISABLED, codes.DHT_DISABLED);
-    }
-    findPeer() {
-        throw new CodeError(messages.DHT_DISABLED, codes.DHT_DISABLED);
-    }
-    getClosestPeers() {
-        throw new CodeError(messages.DHT_DISABLED, codes.DHT_DISABLED);
-    }
-    provide() {
-        throw new CodeError(messages.DHT_DISABLED, codes.DHT_DISABLED);
-    }
-    put() {
-        throw new CodeError(messages.DHT_DISABLED, codes.DHT_DISABLED);
-    }
-    async getMode() {
-        throw new CodeError(messages.DHT_DISABLED, codes.DHT_DISABLED);
-    }
-    async setMode() {
-        throw new CodeError(messages.DHT_DISABLED, codes.DHT_DISABLED);
-    }
-    async refreshRoutingTable() {
-        throw new CodeError(messages.DHT_DISABLED, codes.DHT_DISABLED);
-    }
-}
-//# sourceMappingURL=dummy-dht.js.map

package/dist/src/dht/dummy-dht.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"dummy-dht.js","sourceRoot":"","sources":["../../../src/dht/dummy-dht.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAA;AACrD,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,cAAc,CAAA;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AACxD,OAAO,EAAE,MAAM,EAAE,MAAM,kCAAkC,CAAA;AAEzD,MAAM,OAAO,QAAS,SAAQ,YAAiC;IAC7D,IAAI,CAAC,MAAM,CAAC;QACV,OAAO,IAAI,CAAA;IACb,CAAC;IAED,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC;QACtB,OAAO,mBAAmB,CAAA;IAC5B,CAAC;IAED,IAAI,GAAG;QACL,MAAM,IAAI,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,KAAK,CAAC,YAAY,CAAC,CAAA;IAChE,CAAC;IAED,IAAI,GAAG;QACL,MAAM,IAAI,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,KAAK,CAAC,YAAY,CAAC,CAAA;IAChE,CAAC;IAED,GAAG;QACD,MAAM,IAAI,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,KAAK,CAAC,YAAY,CAAC,CAAA;IAChE,CAAC;IAED,aAAa;QACX,MAAM,IAAI,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,KAAK,CAAC,YAAY,CAAC,CAAA;IAChE,CAAC;IAED,QAAQ;QACN,MAAM,IAAI,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,KAAK,CAAC,YAAY,CAAC,CAAA;IAChE,CAAC;IAED,eAAe;QACb,MAAM,IAAI,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,KAAK,CAAC,YAAY,CAAC,CAAA;IAChE,CAAC;IAED,OAAO;QACL,MAAM,IAAI,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,KAAK,CAAC,YAAY,CAAC,CAAA;IAChE,CAAC;IAED,GAAG;QACD,MAAM,IAAI,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,KAAK,CAAC,YAAY,CAAC,CAAA;IAChE,CAAC;IAED,KAAK,CAAC,OAAO;QACX,MAAM,IAAI,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,KAAK,CAAC,YAAY,CAAC,CAAA;IAChE,CAAC;IAED,KAAK,CAAC,OAAO;QACX,MAAM,IAAI,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,KAAK,CAAC,YAAY,CAAC,CAAA;IAChE,CAAC;IAED,KAAK,CAAC,mBAAmB;QACvB,MAAM,IAAI,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,KAAK,CAAC,YAAY,CAAC,CAAA;IAChE,CAAC;CACF"}