libp2p 1.7.0 → 1.8.0-3319ff41e

package/dist/src/version.js.map

@@ -1 +1 @@
-{"version":3,"file":"version.js","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,OAAO,GAAG,OAAO,CAAA;AAC9B,MAAM,CAAC,MAAM,IAAI,GAAG,QAAQ,CAAA"}
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,OAAO,GAAG,iBAAiB,CAAA;AACxC,MAAM,CAAC,MAAM,IAAI,GAAG,QAAQ,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2p",
-  "version": "1.7.0",
+  "version": "1.8.0-3319ff41e",
   "description": "JavaScript implementation of libp2p, a modular peer to peer network stack",
   "license": "Apache-2.0 OR MIT",
   "homepage": "https://github.com/libp2p/js-libp2p/tree/main/packages/libp2p#readme",
@@ -85,16 +85,16 @@
     "test:webkit": "aegir test -t browser -f \"./dist/test/**/*.spec.js\" -- --browser webkit"
   },
   "dependencies": {
-    "@libp2p/crypto": "^4.1.4",
-    "@libp2p/interface": "^1.5.0",
-    "@libp2p/interface-internal": "^1.2.4",
-    "@libp2p/logger": "^4.0.15",
-    "@libp2p/multistream-select": "^5.1.12",
-    "@libp2p/peer-collections": "^5.2.4",
-    "@libp2p/peer-id": "^4.1.4",
-    "@libp2p/peer-id-factory": "^4.1.4",
-    "@libp2p/peer-store": "^10.1.0",
-    "@libp2p/utils": "^5.4.4",
+    "@libp2p/crypto": "4.1.5-3319ff41e",
+    "@libp2p/interface": "1.6.0-3319ff41e",
+    "@libp2p/interface-internal": "1.3.0-3319ff41e",
+    "@libp2p/logger": "4.0.16-3319ff41e",
+    "@libp2p/multistream-select": "5.1.13-3319ff41e",
+    "@libp2p/peer-collections": "5.2.5-3319ff41e",
+    "@libp2p/peer-id": "4.2.0-3319ff41e",
+    "@libp2p/peer-id-factory": "4.2.0-3319ff41e",
+    "@libp2p/peer-store": "10.1.1-3319ff41e",
+    "@libp2p/utils": "5.4.5-3319ff41e",
     "@multiformats/dns": "^1.0.6",
     "@multiformats/multiaddr": "^12.2.3",
     "@multiformats/multiaddr-matcher": "^1.2.1",
@@ -106,19 +106,20 @@
     "merge-options": "^3.0.4",
     "multiformats": "^13.1.0",
     "p-defer": "^4.0.1",
+    "progress-events": "^1.0.0",
     "race-event": "^1.3.0",
     "race-signal": "^1.0.2",
     "uint8arrays": "^5.1.0"
   },
   "devDependencies": {
     "@chainsafe/libp2p-yamux": "^6.0.2",
-    "@libp2p/circuit-relay-v2": "^1.1.0",
-    "@libp2p/identify": "^2.1.0",
-    "@libp2p/interface-compliance-tests": "^5.4.7",
-    "@libp2p/mplex": "^10.1.0",
-    "@libp2p/plaintext": "^1.1.0",
-    "@libp2p/tcp": "^9.1.0",
-    "@libp2p/websockets": "^8.1.0",
+    "@libp2p/circuit-relay-v2": "1.1.1-3319ff41e",
+    "@libp2p/identify": "2.1.1-3319ff41e",
+    "@libp2p/interface-compliance-tests": "5.4.8-3319ff41e",
+    "@libp2p/mplex": "10.1.1-3319ff41e",
+    "@libp2p/plaintext": "1.1.1-3319ff41e",
+    "@libp2p/tcp": "9.1.1-3319ff41e",
+    "@libp2p/websockets": "8.1.1-3319ff41e",
     "@multiformats/mafmt": "^12.1.6",
     "aegir": "^43.0.1",
     "delay": "^6.0.0",

package/src/connection-manager/dial-queue.ts

@@ -7,6 +7,7 @@ import { type Multiaddr, type Resolver, resolvers, multiaddr } from '@multiforma
 import { dnsaddrResolver } from '@multiformats/multiaddr/resolvers'
 import { Circuit } from '@multiformats/multiaddr-matcher'
 import { type ClearableSignal, anySignal } from 'any-signal'
+import { CustomProgressEvent } from 'progress-events'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { codes } from '../errors.js'
 import { getPeerAddress } from '../get-peer.js'
@@ -19,21 +20,17 @@ import {
 } from './constants.js'
 import { resolveMultiaddrs } from './utils.js'
 import { DEFAULT_DIAL_PRIORITY } from './index.js'
-import type { AddressSorter, AbortOptions, ComponentLogger, Logger, Connection, ConnectionGater, Metrics, PeerId, Address, PeerStore, PeerRouting, IsDialableOptions } from '@libp2p/interface'
-import type { TransportManager } from '@libp2p/interface-internal'
+import type { AddressSorter, ComponentLogger, Logger, Connection, ConnectionGater, Metrics, PeerId, Address, PeerStore, PeerRouting, IsDialableOptions, OpenConnectionProgressEvents } from '@libp2p/interface'
+import type { OpenConnectionOptions, TransportManager } from '@libp2p/interface-internal'
 import type { DNS } from '@multiformats/dns'
+import type { ProgressOptions } from 'progress-events'
 
 export interface PendingDialTarget {
   resolve(value: any): void
   reject(err: Error): void
 }
 
-export interface DialOptions extends AbortOptions {
-  priority?: number
-  force?: boolean
-}
-
-interface DialQueueJobOptions extends PriorityQueueJobOptions {
+interface DialQueueJobOptions extends PriorityQueueJobOptions, ProgressOptions<OpenConnectionProgressEvents> {
   peerId?: PeerId
   multiaddrs: Set<string>
 }
@@ -134,7 +131,7 @@ export class DialQueue {
    * The dial to the first address that is successfully able to upgrade a
    * connection will be used, all other dials will be aborted when that happens.
    */
-  async dial (peerIdOrMultiaddr: PeerId | Multiaddr | Multiaddr[], options: DialOptions = {}): Promise<Connection> {
+  async dial (peerIdOrMultiaddr: PeerId | Multiaddr | Multiaddr[], options: OpenConnectionOptions = {}): Promise<Connection> {
     const { peerId, multiaddrs } = getPeerAddress(peerIdOrMultiaddr)
 
     // make sure we don't have an existing connection to any of the addresses we
@@ -155,6 +152,7 @@ export class DialQueue {
 
     if (existingConnection != null) {
       this.log('already connected to %a', existingConnection.remoteAddr)
+      options.onProgress?.(new CustomProgressEvent('dial-queue:already-connected'))
       return existingConnection
     }
 
@@ -189,6 +187,7 @@ export class DialQueue {
         existingDial.options.multiaddrs.add(multiaddr.toString())
       }
 
+      options.onProgress?.(new CustomProgressEvent('dial-queue:already-in-dial-queue'))
       return existingDial.join(options)
     }
 
@@ -198,7 +197,9 @@ export class DialQueue {
 
     this.log('creating dial target for %p', peerId, multiaddrs.map(ma => ma.toString()))
 
+    options.onProgress?.(new CustomProgressEvent('dial-queue:add-to-dial-queue'))
     return this.queue.add(async (options) => {
+      options?.onProgress?.(new CustomProgressEvent('dial-queue:start-dial'))
       // create abort conditions - need to do this before `calculateMultiaddrs` as
       // we may be about to resolve a dns addr which can time out
       const signal = this.createDialAbortController(options?.signal)
@@ -212,6 +213,8 @@ export class DialQueue {
           signal
         })
 
+        options?.onProgress?.(new CustomProgressEvent<Address[]>('dial-queue:calculated-addresses', addrsToDial))
+
         addrsToDial.map(({ multiaddr }) => multiaddr.toString()).forEach(addr => {
           options?.multiaddrs.add(addr)
         })
@@ -280,7 +283,8 @@ export class DialQueue {
       peerId,
       priority: options.priority ?? DEFAULT_DIAL_PRIORITY,
       multiaddrs: new Set(multiaddrs.map(ma => ma.toString())),
-      signal: options.signal
+      signal: options.signal,
+      onProgress: options.onProgress
     })
   }
 
@@ -299,7 +303,7 @@ export class DialQueue {
   }
 
   // eslint-disable-next-line complexity
-  private async calculateMultiaddrs (peerId?: PeerId, multiaddrs: Set<string> = new Set<string>(), options: DialOptions = {}): Promise<Address[]> {
+  private async calculateMultiaddrs (peerId?: PeerId, multiaddrs: Set<string> = new Set<string>(), options: OpenConnectionOptions = {}): Promise<Address[]> {
     const addrs: Address[] = [...multiaddrs].map(ma => ({
       multiaddr: multiaddr(ma),
       isCertified: false

package/src/connection-manager/index.ts

@@ -4,6 +4,7 @@ import { defaultAddressSort } from '@libp2p/utils/address-sort'
 import { RateLimiter } from '@libp2p/utils/rate-limiter'
 import { type Multiaddr, type Resolver, multiaddr } from '@multiformats/multiaddr'
 import { dnsaddrResolver } from '@multiformats/multiaddr/resolvers'
+import { CustomProgressEvent } from 'progress-events'
 import { codes } from '../errors.js'
 import { getPeerAddress } from '../get-peer.js'
 import { AutoDial } from './auto-dial.js'
@@ -509,6 +510,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
       if (existingConnection != null) {
         this.log('had an existing non-transient connection to %p', peerId)
 
+        options.onProgress?.(new CustomProgressEvent('dial-queue:already-connected'))
         return existingConnection
       }
     }

package/src/libp2p.ts

@@ -24,7 +24,7 @@ import { DefaultUpgrader } from './upgrader.js'
 import * as pkg from './version.js'
 import type { Components } from './components.js'
 import type { Libp2p, Libp2pInit, Libp2pOptions } from './index.js'
-import type { PeerRouting, ContentRouting, Libp2pEvents, PendingDial, ServiceMap, AbortOptions, ComponentLogger, Logger, Connection, NewStreamOptions, Stream, Metrics, PeerId, PeerInfo, PeerStore, Topology, Libp2pStatus, IsDialableOptions } from '@libp2p/interface'
+import type { PeerRouting, ContentRouting, Libp2pEvents, PendingDial, ServiceMap, AbortOptions, ComponentLogger, Logger, Connection, NewStreamOptions, Stream, Metrics, PeerId, PeerInfo, PeerStore, Topology, Libp2pStatus, IsDialableOptions, DialOptions } from '@libp2p/interface'
 import type { StreamHandler, StreamHandlerOptions } from '@libp2p/interface-internal'
 
 export class Libp2pNode<T extends ServiceMap = ServiceMap> extends TypedEventEmitter<Libp2pEvents> implements Libp2p<T> {
@@ -272,7 +272,7 @@ export class Libp2pNode<T extends ServiceMap = ServiceMap> extends TypedEventEmi
     return Array.from(peerSet)
   }
 
-  async dial (peer: PeerId | Multiaddr | Multiaddr[], options: AbortOptions = {}): Promise<Connection> {
+  async dial (peer: PeerId | Multiaddr | Multiaddr[], options: DialOptions = {}): Promise<Connection> {
     return this.components.connectionManager.openConnection(peer, {
       // ensure any userland dials take top priority in the queue
       priority: 75,

package/src/transport-manager.ts

@@ -1,8 +1,9 @@
 import { CodeError, FaultTolerance } from '@libp2p/interface'
 import { trackedMap } from '@libp2p/utils/tracked-map'
+import { CustomProgressEvent } from 'progress-events'
 import { codes } from './errors.js'
-import type { Libp2pEvents, AbortOptions, ComponentLogger, Logger, Connection, TypedEventTarget, Metrics, Startable, Listener, Transport, Upgrader } from '@libp2p/interface'
-import type { AddressManager, TransportManager } from '@libp2p/interface-internal'
+import type { Libp2pEvents, ComponentLogger, Logger, Connection, TypedEventTarget, Metrics, Startable, Listener, Transport, Upgrader } from '@libp2p/interface'
+import type { AddressManager, TransportManager, TransportManagerDialOptions } from '@libp2p/interface-internal'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 export interface TransportManagerInit {
@@ -107,14 +108,19 @@ export class DefaultTransportManager implements TransportManager, Startable {
   /**
    * Dials the given Multiaddr over it's supported transport
    */
-  async dial (ma: Multiaddr, options?: AbortOptions): Promise<Connection> {
+  async dial (ma: Multiaddr, options?: TransportManagerDialOptions): Promise<Connection> {
     const transport = this.dialTransportForMultiaddr(ma)
 
     if (transport == null) {
       throw new CodeError(`No transport available for address ${String(ma)}`, codes.ERR_TRANSPORT_UNAVAILABLE)
     }
 
+    options?.onProgress?.(new CustomProgressEvent<string>('transport-manager:selected-transport', transport[Symbol.toStringTag]))
+
     try {
+      // @ts-expect-error the transport has a typed onProgress option but we
+      // can't predict what transport implementation we selected so all we can
+      // do is pass the onProgress handler in and hope for the best
       return await transport.dial(ma, {
         ...options,
         upgrader: this.components.upgrader

package/src/upgrader.ts

@@ -1,6 +1,7 @@
 import { CodeError, ERR_TIMEOUT, setMaxListeners } from '@libp2p/interface'
 import * as mss from '@libp2p/multistream-select'
 import { peerIdFromString } from '@libp2p/peer-id'
+import { CustomProgressEvent } from 'progress-events'
 import { createConnection } from './connection/index.js'
 import { INBOUND_UPGRADE_TIMEOUT } from './connection-manager/constants.js'
 import { codes } from './errors.js'
@@ -185,6 +186,8 @@ export class DefaultUpgrader implements Upgrader {
         // Encrypt the connection
         encryptedConn = protectedConn
         if (opts?.skipEncryption !== true) {
+          opts?.onProgress?.(new CustomProgressEvent('upgrader:encrypt-inbound-connection'));
+
           ({
             conn: encryptedConn,
             remotePeer,
@@ -214,6 +217,8 @@ export class DefaultUpgrader implements Upgrader {
         if (opts?.muxerFactory != null) {
           muxerFactory = opts.muxerFactory
         } else if (this.muxers.size > 0) {
+          opts?.onProgress?.(new CustomProgressEvent('upgrader:multiplex-inbound-connection'))
+
           // Multiplex the connection
           const multiplexed = await this._multiplexInbound({
             ...protectedConn,

package/src/version.ts

@@ -1,2 +1,2 @@
-export const version = '1.7.0'
+export const version = '1.8.0-3319ff41e'
 export const name = 'libp2p'

package/dist/typedoc-urls.json

@@ -1,14 +0,0 @@
-{
-  "Libp2pInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.Libp2pInit.html",
-  ".:Libp2pInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.Libp2pInit.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",
-  "createLibp2p": "https://libp2p.github.io/js-libp2p/functions/libp2p.index.createLibp2p.html",
-  ".:createLibp2p": "https://libp2p.github.io/js-libp2p/functions/libp2p.index.createLibp2p.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"
-}