libp2p 3.1.7 → 3.2.0-90100be0c

package/src/connection-manager/index.ts

@@ -12,7 +12,7 @@ import { ReconnectQueue } from './reconnect-queue.js'
 import { dnsaddrResolver } from './resolvers/index.ts'
 import { findExistingConnection, multiaddrToIpNet } from './utils.js'
 import type { IpNet } from '@chainsafe/netmask'
-import type { PendingDial, AddressSorter, Libp2pEvents, AbortOptions, ComponentLogger, Logger, Connection, MultiaddrConnection, ConnectionGater, Metrics, PeerId, PeerStore, Startable, PendingDialStatus, PeerRouting, IsDialableOptions, MultiaddrResolver, Stream, NewStreamOptions } from '@libp2p/interface'
+import type { PendingDial, AddressSorter, Libp2pEvents, AbortOptions, ComponentLogger, Logger, Connection, MultiaddrConnection, ConnectionGater, Metrics, PeerId, PeerStore, Startable, PendingDialStatus, PeerRouting, IsDialableOptions, MultiaddrResolver, Stream, NewStreamOptions, DialTarget } from '@libp2p/interface'
 import type { ConnectionManager, OpenConnectionOptions, TransportManager } from '@libp2p/interface-internal'
 import type { JobStatus } from '@libp2p/utils'
 import type { Multiaddr } from '@multiformats/multiaddr'
@@ -523,7 +523,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
     return this.connections
   }
 
-  async openConnection (peerIdOrMultiaddr: PeerId | Multiaddr | Multiaddr[], options: OpenConnectionOptions = {}): Promise<Connection> {
+  async openConnection (peerIdOrMultiaddr: DialTarget, options: OpenConnectionOptions = {}): Promise<Connection> {
     if (!this.started) {
       throw new NotStartedError('Not started')
     }
@@ -532,6 +532,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
 
     try {
       options.signal?.throwIfAborted()
+      options?.onProgress?.(new CustomProgressEvent('connection:open', peerIdOrMultiaddr))
 
       const { peerId, multiaddrs } = getPeerAddress(peerIdOrMultiaddr)
 
@@ -547,6 +548,8 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
           this.log('had an existing connection to %p as %a', peerId, existingConnection.remoteAddr)
 
           options.onProgress?.(new CustomProgressEvent('dial-queue:already-connected'))
+          options.onProgress?.(new CustomProgressEvent('connection:opened', existingConnection))
+
           return existingConnection
         }
       }
@@ -590,13 +593,15 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
         peerConnections.push(connection)
       }
 
+      options.onProgress?.(new CustomProgressEvent('connection:opened', connection))
+
       return connection
     } finally {
       this.outboundPendingConnections--
     }
   }
 
-  async openStream (peerIdOrMultiaddr: PeerId | Multiaddr | Multiaddr[], protocol: string | string[], options: OpenConnectionOptions & NewStreamOptions = {}): Promise<Stream> {
+  async openStream (peerIdOrMultiaddr: DialTarget, protocol: string | string[], options: OpenConnectionOptions & NewStreamOptions = {}): Promise<Stream> {
     const connection = await this.openConnection(peerIdOrMultiaddr, options)
 
     return connection.newStream(protocol, options)

package/src/connection.ts

@@ -2,11 +2,12 @@ import { connectionSymbol, LimitedConnectionError, ConnectionClosedError, TooMan
 import * as mss from '@libp2p/multistream-select'
 import { CODE_P2P } from '@multiformats/multiaddr'
 import { setMaxListeners, TypedEventEmitter } from 'main-event'
+import { CustomProgressEvent } from 'progress-events'
 import { CONNECTION_CLOSE_TIMEOUT, PROTOCOL_NEGOTIATION_TIMEOUT } from './connection-manager/constants.defaults.ts'
 import { isDirect } from './connection-manager/utils.ts'
 import { MuxerUnavailableError } from './errors.ts'
 import { DEFAULT_MAX_INBOUND_STREAMS, DEFAULT_MAX_OUTBOUND_STREAMS } from './registrar.ts'
-import type { AbortOptions, Logger, MessageStreamDirection, Connection as ConnectionInterface, Stream, NewStreamOptions, PeerId, ConnectionLimits, StreamMuxer, Metrics, PeerStore, MultiaddrConnection, MessageStreamEvents, MultiaddrConnectionTimeline, ConnectionStatus, MessageStream, StreamMiddleware } from '@libp2p/interface'
+import type { AbortOptions, Logger, MessageStreamDirection, Connection as ConnectionInterface, Stream, NewStreamOptions, PeerId, ConnectionLimits, StreamMuxer, Metrics, PeerStore, MultiaddrConnection, MessageStreamEvents, MultiaddrConnectionTimeline, ConnectionStatus, MessageStream, StreamMiddleware, OpenStreamEvent, OpenedStreamEvent } from '@libp2p/interface'
 import type { Registrar } from '@libp2p/interface-internal'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
@@ -125,6 +126,11 @@ export class Connection extends TypedEventEmitter<MessageStreamEvents> implement
       protocols = [protocols]
     }
 
+    options.onProgress?.(new CustomProgressEvent<OpenStreamEvent>('connection:open-stream', {
+      connection: this,
+      protocols
+    }))
+
     this.log.trace('starting new stream for protocols %s', protocols)
     const muxedStream = await this.muxer.createStream({
       ...options,
@@ -179,7 +185,14 @@ export class Connection extends TypedEventEmitter<MessageStreamEvents> implement
 
       const middleware = this.components.registrar.getMiddleware(muxedStream.protocol)
 
-      return await this.runMiddlewareChain(muxedStream, this, middleware)
+      const stream = await this.runMiddlewareChain(muxedStream, this, middleware)
+
+      options.onProgress?.(new CustomProgressEvent<OpenedStreamEvent>('connection:opened-stream', {
+        connection: this,
+        stream
+      }))
+
+      return stream
     } catch (err: any) {
       if (muxedStream.status === 'open') {
         muxedStream.abort(err)

package/src/get-peer.ts

@@ -2,7 +2,7 @@ import { InvalidMultiaddrError, InvalidParametersError, isPeerId } from '@libp2p
 import { peerIdFromString } from '@libp2p/peer-id'
 import { CODE_P2P, isMultiaddr } from '@multiformats/multiaddr'
 import { PEER_ID } from '@multiformats/multiaddr-matcher'
-import type { PeerId } from '@libp2p/interface'
+import type { DialTarget, PeerId } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 export interface PeerAddress {
@@ -14,7 +14,7 @@ export interface PeerAddress {
  * Extracts a PeerId and/or multiaddr from the passed PeerId or Multiaddr or an
  * array of Multiaddrs
  */
-export function getPeerAddress (peer: PeerId | Multiaddr | Multiaddr[]): PeerAddress {
+export function getPeerAddress (peer: DialTarget): PeerAddress {
   if (isPeerId(peer)) {
     return { peerId: peer, multiaddrs: [] }
   }

package/src/libp2p.ts

@@ -24,7 +24,7 @@ import { userAgent } from './user-agent.js'
 import * as pkg from './version.js'
 import type { Components } from './components.js'
 import type { Libp2p as Libp2pInterface, Libp2pInit } from './index.js'
-import type { PeerRouting, ContentRouting, Libp2pEvents, PendingDial, ServiceMap, AbortOptions, ComponentLogger, Logger, Connection, NewStreamOptions, Stream, Metrics, PeerId, PeerInfo, PeerStore, Topology, Libp2pStatus, IsDialableOptions, DialOptions, PublicKey, Ed25519PeerId, Secp256k1PeerId, RSAPublicKey, RSAPeerId, URLPeerId, Ed25519PublicKey, Secp256k1PublicKey, StreamHandler, StreamHandlerOptions, StreamMiddleware } from '@libp2p/interface'
+import type { PeerRouting, ContentRouting, Libp2pEvents, PendingDial, ServiceMap, AbortOptions, ComponentLogger, Logger, Connection, Stream, Metrics, PeerId, PeerInfo, PeerStore, Topology, Libp2pStatus, IsDialableOptions, DialOptions, PublicKey, Ed25519PeerId, Secp256k1PeerId, RSAPublicKey, RSAPeerId, URLPeerId, Ed25519PublicKey, Secp256k1PublicKey, StreamHandler, StreamHandlerOptions, StreamMiddleware, DialTarget, DialProtocolOptions } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 export class Libp2p<T extends ServiceMap = ServiceMap> extends TypedEventEmitter<Libp2pEvents> implements Libp2pInterface<T> {
@@ -286,7 +286,7 @@ export class Libp2p<T extends ServiceMap = ServiceMap> extends TypedEventEmitter
     return Array.from(peerSet)
   }
 
-  async dial (peer: PeerId | Multiaddr | Multiaddr[], options: DialOptions = {}): Promise<Connection> {
+  async dial (peer: DialTarget, options: DialOptions = {}): Promise<Connection> {
     return this.components.connectionManager.openConnection(peer, {
       // ensure any userland dials take top priority in the queue
       priority: 75,
@@ -294,7 +294,7 @@ export class Libp2p<T extends ServiceMap = ServiceMap> extends TypedEventEmitter
     })
   }
 
-  async dialProtocol (peer: PeerId | Multiaddr | Multiaddr[], protocols: string | string[], options: NewStreamOptions = {}): Promise<Stream> {
+  async dialProtocol (peer: DialTarget, protocols: string | string[], options: DialProtocolOptions = {}): Promise<Stream> {
     if (protocols == null) {
       throw new InvalidParametersError('no protocols were provided to open a stream')
     }

package/src/version.ts

@@ -1,2 +1,2 @@
-export const version = '3.1.7'
+export const version = '3.2.0-90100be0c'
 export const name = 'js-libp2p'

package/dist/typedoc-urls.json

@@ -1,24 +0,0 @@
-{
-  "AddressFilter": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.AddressFilter.html",
-  "AddressManagerInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.AddressManagerInit.html",
-  "ConnectionManagerInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.ConnectionManagerInit.html",
-  "ConnectionMonitorInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.ConnectionMonitorInit.html",
-  "Libp2pInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.Libp2pInit.html",
-  ".:Libp2pInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.Libp2pInit.html",
-  "TransportManagerInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.TransportManagerInit.html",
-  "Libp2pOptions": "https://libp2p.github.io/js-libp2p/types/libp2p.index.Libp2pOptions.html",
-  ".:Libp2pOptions": "https://libp2p.github.io/js-libp2p/types/libp2p.index.Libp2pOptions.html",
-  "ServiceFactoryMap": "https://libp2p.github.io/js-libp2p/types/libp2p.index.ServiceFactoryMap.html",
-  ".:ServiceFactoryMap": "https://libp2p.github.io/js-libp2p/types/libp2p.index.ServiceFactoryMap.html",
-  "dnsaddrResolver": "https://libp2p.github.io/js-libp2p/variables/libp2p.index.dnsaddrResolver.html",
-  "createLibp2p": "https://libp2p.github.io/js-libp2p/functions/libp2p.index.createLibp2p.html",
-  ".:createLibp2p": "https://libp2p.github.io/js-libp2p/functions/libp2p.index.createLibp2p.html",
-  "isLibp2p": "https://libp2p.github.io/js-libp2p/functions/libp2p.index.isLibp2p.html",
-  ".:isLibp2p": "https://libp2p.github.io/js-libp2p/functions/libp2p.index.isLibp2p.html",
-  "userAgent": "https://libp2p.github.io/js-libp2p/functions/libp2p.user-agent.userAgent.html",
-  "./user-agent:userAgent": "https://libp2p.github.io/js-libp2p/functions/libp2p.user-agent.userAgent.html",
-  "name": "https://libp2p.github.io/js-libp2p/variables/libp2p.version.name.html",
-  "./version:name": "https://libp2p.github.io/js-libp2p/variables/libp2p.version.name.html",
-  "version": "https://libp2p.github.io/js-libp2p/variables/libp2p.version.version.html",
-  "./version:version": "https://libp2p.github.io/js-libp2p/variables/libp2p.version.version.html"
-}