libp2p 1.9.4 → 2.0.0-7cd984569

package/src/libp2p.ts

@@ -1,9 +1,8 @@
-import { unmarshalPrivateKey, unmarshalPublicKey } from '@libp2p/crypto/keys'
-import { contentRoutingSymbol, CodeError, TypedEventEmitter, CustomEvent, setMaxListeners, peerDiscoverySymbol, peerRoutingSymbol } from '@libp2p/interface'
+import { publicKeyFromProtobuf } from '@libp2p/crypto/keys'
+import { contentRoutingSymbol, TypedEventEmitter, setMaxListeners, peerDiscoverySymbol, peerRoutingSymbol, InvalidParametersError } from '@libp2p/interface'
 import { defaultLogger } from '@libp2p/logger'
 import { PeerSet } from '@libp2p/peer-collections'
 import { peerIdFromString } from '@libp2p/peer-id'
-import { createEd25519PeerId } from '@libp2p/peer-id-factory'
 import { PersistentPeerStore } from '@libp2p/peer-store'
 import { isMultiaddr, type Multiaddr } from '@multiformats/multiaddr'
 import { MemoryDatastore } from 'datastore-core/memory'
@@ -12,11 +11,9 @@ import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { DefaultAddressManager } from './address-manager/index.js'
 import { checkServiceDependencies, defaultComponents } from './components.js'
 import { connectionGater } from './config/connection-gater.js'
-import { validateConfig } from './config.js'
 import { DefaultConnectionManager } from './connection-manager/index.js'
 import { ConnectionMonitor } from './connection-monitor.js'
 import { CompoundContentRouting } from './content-routing.js'
-import { codes } from './errors.js'
 import { DefaultPeerRouting } from './peer-routing.js'
 import { RandomWalk } from './random-walk.js'
 import { DefaultRegistrar } from './registrar.js'
@@ -24,11 +21,11 @@ import { DefaultTransportManager } from './transport-manager.js'
 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, DialOptions } from '@libp2p/interface'
+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 } from '@libp2p/interface'
 import type { StreamHandler, StreamHandlerOptions } from '@libp2p/interface-internal'
 
-export class Libp2pNode<T extends ServiceMap = ServiceMap> extends TypedEventEmitter<Libp2pEvents> implements Libp2p<T> {
+export class Libp2p<T extends ServiceMap = ServiceMap> extends TypedEventEmitter<Libp2pEvents> implements Libp2pInterface<T> {
   public peerId: PeerId
   public peerStore: PeerStore
   public contentRouting: ContentRouting
@@ -41,7 +38,7 @@ export class Libp2pNode<T extends ServiceMap = ServiceMap> extends TypedEventEmi
   public components: Components & T
   private readonly log: Logger
 
-  constructor (init: Libp2pInit<T> & Required<Pick<Libp2pInit<T>, 'peerId'>>) {
+  constructor (init: Libp2pInit<T> & { peerId: PeerId }) {
     super()
 
     this.status = 'stopped'
@@ -111,8 +108,8 @@ export class Libp2pNode<T extends ServiceMap = ServiceMap> extends TypedEventEmi
 
     // Set up the Upgrader
     this.components.upgrader = new DefaultUpgrader(this.components, {
-      connectionEncryption: (init.connectionEncryption ?? []).map((fn, index) => this.configureComponent(`connection-encryption-${index}`, fn(this.components))),
-      muxers: (init.streamMuxers ?? []).map((fn, index) => this.configureComponent(`stream-muxers-${index}`, fn(this.components))),
+      connectionEncrypters: (init.connectionEncrypters ?? []).map((fn, index) => this.configureComponent(`connection-encryption-${index}`, fn(this.components))),
+      streamMuxers: (init.streamMuxers ?? []).map((fn, index) => this.configureComponent(`stream-muxers-${index}`, fn(this.components))),
       inboundUpgradeTimeout: init.connectionManager?.inboundUpgradeTimeout
     })
 
@@ -288,13 +285,13 @@ export class Libp2pNode<T extends ServiceMap = ServiceMap> extends TypedEventEmi
 
   async dialProtocol (peer: PeerId | Multiaddr | Multiaddr[], protocols: string | string[], options: NewStreamOptions = {}): Promise<Stream> {
     if (protocols == null) {
-      throw new CodeError('no protocols were provided to open a stream', codes.ERR_INVALID_PROTOCOLS_FOR_STREAM)
+      throw new InvalidParametersError('no protocols were provided to open a stream')
     }
 
     protocols = Array.isArray(protocols) ? protocols : [protocols]
 
     if (protocols.length === 0) {
-      throw new CodeError('no protocols were provided to open a stream', codes.ERR_INVALID_PROTOCOLS_FOR_STREAM)
+      throw new InvalidParametersError('no protocols were provided to open a stream')
     }
 
     const connection = await this.dial(peer, options)
@@ -321,7 +318,12 @@ export class Libp2pNode<T extends ServiceMap = ServiceMap> extends TypedEventEmi
   /**
    * Get the public key for the given peer id
    */
-  async getPublicKey (peer: PeerId, options: AbortOptions = {}): Promise<Uint8Array> {
+  async getPublicKey (peer: Ed25519PeerId, options?: AbortOptions): Promise<Ed25519PublicKey>
+  async getPublicKey (peer: Secp256k1PeerId, options?: AbortOptions): Promise<Secp256k1PublicKey>
+  async getPublicKey (peer: RSAPeerId, options?: AbortOptions): Promise<RSAPublicKey>
+  async getPublicKey (peer: URLPeerId, options?: AbortOptions): Promise<never>
+  async getPublicKey (peer: PeerId, options?: AbortOptions): Promise<PublicKey>
+  async getPublicKey (peer: PeerId, options: AbortOptions = {}): Promise<PublicKey> {
     this.log('getPublicKey %p', peer)
 
     if (peer.publicKey != null) {
@@ -335,27 +337,27 @@ export class Libp2pNode<T extends ServiceMap = ServiceMap> extends TypedEventEmi
         return peerInfo.id.publicKey
       }
     } catch (err: any) {
-      if (err.code !== codes.ERR_NOT_FOUND) {
+      if (err.name !== 'NotFoundError') {
         throw err
       }
     }
 
     const peerKey = uint8ArrayConcat([
       uint8ArrayFromString('/pk/'),
-      peer.multihash.digest
+      peer.toMultihash().bytes
     ])
 
     // search any available content routing methods
     const bytes = await this.contentRouting.get(peerKey, options)
 
     // ensure the returned key is valid
-    unmarshalPublicKey(bytes)
+    const publicKey = publicKeyFromProtobuf(bytes)
 
     await this.peerStore.patch(peer, {
-      publicKey: bytes
+      publicKey
     })
 
-    return bytes
+    return publicKey
   }
 
   async handle (protocols: string | string[], handler: StreamHandler, options?: StreamHandlerOptions): Promise<void> {
@@ -402,7 +404,7 @@ export class Libp2pNode<T extends ServiceMap = ServiceMap> extends TypedEventEmi
     const { detail: peer } = evt
 
     if (peer.id.toString() === this.peerId.toString()) {
-      this.log.error(new Error(codes.ERR_DISCOVERED_SELF))
+      this.log.error('peer discovery mechanism discovered self')
       return
     }
 
@@ -412,19 +414,3 @@ export class Libp2pNode<T extends ServiceMap = ServiceMap> extends TypedEventEmi
       .catch(err => { this.log.error(err) })
   }
 }
-
-/**
- * Returns a new Libp2pNode instance - this exposes more of the internals than the
- * libp2p interface and is useful for testing and debugging.
- */
-export async function createLibp2pNode <T extends ServiceMap = ServiceMap> (options: Libp2pOptions<T> = {}): Promise<Libp2pNode<T>> {
-  const peerId = options.peerId ??= await createEd25519PeerId()
-
-  if (peerId.privateKey == null) {
-    throw new CodeError('peer id was missing private key', 'ERR_MISSING_PRIVATE_KEY')
-  }
-
-  options.privateKey ??= await unmarshalPrivateKey(peerId.privateKey)
-
-  return new Libp2pNode(await validateConfig(options))
-}

package/src/peer-routing.ts

@@ -1,8 +1,8 @@
-import { CodeError } from '@libp2p/interface'
+import { NotFoundError } from '@libp2p/interface'
 import { createScalableCuckooFilter } from '@libp2p/utils/filters'
 import merge from 'it-merge'
 import parallel from 'it-parallel'
-import { codes, messages } from './errors.js'
+import { NoPeerRoutersError, QueriedForSelfError } from './errors.js'
 import type { Logger, PeerId, PeerInfo, PeerRouting, PeerStore, RoutingOptions } from '@libp2p/interface'
 import type { ComponentLogger } from '@libp2p/logger'
 
@@ -36,11 +36,11 @@ export class DefaultPeerRouting implements PeerRouting {
    */
   async findPeer (id: PeerId, options?: RoutingOptions): Promise<PeerInfo> {
     if (this.routers.length === 0) {
-      throw new CodeError('No peer routers available', codes.ERR_NO_ROUTERS_AVAILABLE)
+      throw new NoPeerRoutersError('No peer routers available')
     }
 
     if (id.toString() === this.peerId.toString()) {
-      throw new CodeError('Should not try to find self', codes.ERR_FIND_SELF)
+      throw new QueriedForSelfError('Should not try to find self')
     }
 
     const self = this
@@ -69,7 +69,7 @@ export class DefaultPeerRouting implements PeerRouting {
       return peer
     }
 
-    throw new CodeError(messages.NOT_FOUND, codes.ERR_NOT_FOUND)
+    throw new NotFoundError()
   }
 
   /**
@@ -77,7 +77,7 @@ export class DefaultPeerRouting implements PeerRouting {
    */
   async * getClosestPeers (key: Uint8Array, options: RoutingOptions = {}): AsyncIterable<PeerInfo> {
     if (this.routers.length === 0) {
-      throw new CodeError('No peer routers available', codes.ERR_NO_ROUTERS_AVAILABLE)
+      throw new NoPeerRoutersError('No peer routers available')
     }
 
     const self = this
@@ -121,11 +121,11 @@ export class DefaultPeerRouting implements PeerRouting {
       }
 
       // deduplicate peers
-      if (seen.has(peer.id.toBytes())) {
+      if (seen.has(peer.id.toMultihash().bytes)) {
         continue
       }
 
-      seen.add(peer.id.toBytes())
+      seen.add(peer.id.toMultihash().bytes)
 
       yield peer
     }

package/src/registrar.ts

@@ -1,6 +1,6 @@
-import { CodeError } from '@libp2p/interface'
+import { InvalidParametersError } from '@libp2p/interface'
 import merge from 'merge-options'
-import { codes } from './errors.js'
+import * as errorsJs from './errors.js'
 import type { IdentifyResult, Libp2pEvents, Logger, PeerUpdate, TypedEventTarget, PeerId, PeerStore, Topology } from '@libp2p/interface'
 import type { ConnectionManager, StreamHandlerOptions, StreamHandlerRecord, Registrar, StreamHandler } from '@libp2p/interface-internal'
 import type { ComponentLogger } from '@libp2p/logger'
@@ -52,7 +52,7 @@ export class DefaultRegistrar implements Registrar {
     const handler = this.handlers.get(protocol)
 
     if (handler == null) {
-      throw new CodeError(`No handler registered for protocol ${protocol}`, codes.ERR_NO_HANDLER_FOR_PROTOCOL)
+      throw new errorsJs.UnhandledProtocolError(`No handler registered for protocol ${protocol}`)
     }
 
     return handler
@@ -75,7 +75,7 @@ export class DefaultRegistrar implements Registrar {
    */
   async handle (protocol: string, handler: StreamHandler, opts?: StreamHandlerOptions): Promise<void> {
     if (this.handlers.has(protocol)) {
-      throw new CodeError(`Handler already registered for protocol ${protocol}`, codes.ERR_PROTOCOL_HANDLER_ALREADY_REGISTERED)
+      throw new errorsJs.DuplicateProtocolHandlerError(`Handler already registered for protocol ${protocol}`)
     }
 
     const options = merge.bind({ ignoreUndefined: true })({
@@ -116,7 +116,7 @@ export class DefaultRegistrar implements Registrar {
    */
   async register (protocol: string, topology: Topology): Promise<string> {
     if (topology == null) {
-      throw new CodeError('invalid topology', codes.ERR_INVALID_PARAMETERS)
+      throw new InvalidParametersError('invalid topology')
     }
 
     // Create topology
@@ -176,7 +176,7 @@ export class DefaultRegistrar implements Registrar {
         }
       })
       .catch(err => {
-        if (err.code === codes.ERR_NOT_FOUND) {
+        if (err.name === 'NotFoundError') {
           // peer has not completed identify so they are not in the peer store
           return
         }
@@ -230,7 +230,7 @@ export class DefaultRegistrar implements Registrar {
       }
 
       for (const topology of topologies.values()) {
-        if (connection.transient && topology.notifyOnTransient !== true) {
+        if (connection.limits != null && topology.notifyOnLimitedConnection !== true) {
           continue
         }
 

package/src/transport-manager.ts

@@ -1,7 +1,7 @@
-import { CodeError, FaultTolerance } from '@libp2p/interface'
+import { FaultTolerance, InvalidParametersError, NotStartedError } from '@libp2p/interface'
 import { trackedMap } from '@libp2p/utils/tracked-map'
 import { CustomProgressEvent } from 'progress-events'
-import { codes } from './errors.js'
+import { NoValidAddressesError, TransportUnavailableError } from './errors.js'
 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'
@@ -47,11 +47,11 @@ export class DefaultTransportManager implements TransportManager, Startable {
     const tag = transport[Symbol.toStringTag]
 
     if (tag == null) {
-      throw new CodeError('Transport must have a valid tag', codes.ERR_INVALID_KEY)
+      throw new InvalidParametersError('Transport must have a valid tag')
     }
 
     if (this.transports.has(tag)) {
-      throw new CodeError(`There is already a transport with the tag ${tag}`, codes.ERR_DUPLICATE_TRANSPORT)
+      throw new InvalidParametersError(`There is already a transport with the tag ${tag}`)
     }
 
     this.log('adding transport %s', tag)
@@ -112,26 +112,18 @@ export class DefaultTransportManager implements TransportManager, Startable {
     const transport = this.dialTransportForMultiaddr(ma)
 
     if (transport == null) {
-      throw new CodeError(`No transport available for address ${String(ma)}`, codes.ERR_TRANSPORT_UNAVAILABLE)
+      throw new TransportUnavailableError(`No transport available for address ${String(ma)}`)
     }
 
     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
-      })
-    } catch (err: any) {
-      if (err.code == null) {
-        err.code = codes.ERR_TRANSPORT_DIAL_FAILED
-      }
-
-      throw err
-    }
+    // @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 transport.dial(ma, {
+      ...options,
+      upgrader: this.components.upgrader
+    })
   }
 
   /**
@@ -192,7 +184,7 @@ export class DefaultTransportManager implements TransportManager, Startable {
    */
   async listen (addrs: Multiaddr[]): Promise<void> {
     if (!this.isStarted()) {
-      throw new CodeError('Not started', codes.ERR_NODE_NOT_STARTED)
+      throw new NotStartedError('Not started')
     }
 
     if (addrs == null || addrs.length === 0) {
@@ -256,7 +248,7 @@ export class DefaultTransportManager implements TransportManager, Startable {
       // just wait for any (`p-any`) listener to succeed on each transport before returning
       const isListening = results.find(r => r.status === 'fulfilled')
       if ((isListening == null) && this.faultTolerance !== FaultTolerance.NO_FATAL) {
-        throw new CodeError(`Transport (${key}) could not listen on any available address`, codes.ERR_NO_VALID_ADDRESSES)
+        throw new NoValidAddressesError(`Transport (${key}) could not listen on any available address`)
       }
     }
 
@@ -265,7 +257,7 @@ export class DefaultTransportManager implements TransportManager, Startable {
     if (couldNotListen.length === this.transports.size) {
       const message = `no valid addresses were provided for transports [${couldNotListen.join(', ')}]`
       if (this.faultTolerance === FaultTolerance.FATAL_ALL) {
-        throw new CodeError(message, codes.ERR_NO_VALID_ADDRESSES)
+        throw new NoValidAddressesError(message)
       }
       this.log(`libp2p in dial mode only: ${message}`)
     }