libp2p 1.9.3 → 1.9.4-5214dec4a

package/src/content-routing.ts

@@ -1,7 +1,7 @@
-import { CodeError } from '@libp2p/interface'
+import { NotStartedError } from '@libp2p/interface'
 import { PeerSet } from '@libp2p/peer-collections'
 import merge from 'it-merge'
-import { codes, messages } from './errors.js'
+import { NoContentRoutersError } from './errors.js'
 import type { AbortOptions, ComponentLogger, ContentRouting, PeerInfo, PeerRouting, PeerStore, RoutingOptions, Startable } from '@libp2p/interface'
 import type { CID } from 'multiformats/cid'
 
@@ -45,7 +45,7 @@ export class CompoundContentRouting implements ContentRouting, Startable {
    */
   async * findProviders (key: CID, options: RoutingOptions = {}): AsyncIterable<PeerInfo> {
     if (this.routers.length === 0) {
-      throw new CodeError('No content routers available', codes.ERR_NO_ROUTERS_AVAILABLE)
+      throw new NoContentRoutersError('No content routers available')
     }
 
     const self = this
@@ -84,7 +84,7 @@ export class CompoundContentRouting implements ContentRouting, Startable {
    */
   async provide (key: CID, options: AbortOptions = {}): Promise<void> {
     if (this.routers.length === 0) {
-      throw new CodeError('No content routers available', codes.ERR_NO_ROUTERS_AVAILABLE)
+      throw new NoContentRoutersError('No content routers available')
     }
 
     await Promise.all(this.routers.map(async (router) => {
@@ -97,7 +97,7 @@ export class CompoundContentRouting implements ContentRouting, Startable {
    */
   async put (key: Uint8Array, value: Uint8Array, options?: AbortOptions): Promise<void> {
     if (!this.isStarted()) {
-      throw new CodeError(messages.NOT_STARTED_YET, codes.ERR_NODE_NOT_STARTED)
+      throw new NotStartedError()
     }
 
     await Promise.all(this.routers.map(async (router) => {
@@ -111,7 +111,7 @@ export class CompoundContentRouting implements ContentRouting, Startable {
    */
   async get (key: Uint8Array, options?: AbortOptions): Promise<Uint8Array> {
     if (!this.isStarted()) {
-      throw new CodeError(messages.NOT_STARTED_YET, codes.ERR_NODE_NOT_STARTED)
+      throw new NotStartedError()
     }
 
     return Promise.any(this.routers.map(async (router) => {

package/src/errors.ts

@@ -1,67 +1,102 @@
 export enum messages {
   NOT_STARTED_YET = 'The libp2p node is not started yet',
-  ERR_PROTECTOR_REQUIRED = 'Private network is enforced, but no protector was provided',
   NOT_FOUND = 'Not found'
 }
 
-export enum codes {
-  ERR_PROTECTOR_REQUIRED = 'ERR_PROTECTOR_REQUIRED',
-  ERR_PEER_DIAL_INTERCEPTED = 'ERR_PEER_DIAL_INTERCEPTED',
-  ERR_CONNECTION_INTERCEPTED = 'ERR_CONNECTION_INTERCEPTED',
-  ERR_INVALID_PROTOCOLS_FOR_STREAM = 'ERR_INVALID_PROTOCOLS_FOR_STREAM',
-  ERR_CONNECTION_ENDED = 'ERR_CONNECTION_ENDED',
-  ERR_CONNECTION_FAILED = 'ERR_CONNECTION_FAILED',
-  ERR_NODE_NOT_STARTED = 'ERR_NODE_NOT_STARTED',
-  ERR_ALREADY_ABORTED = 'ERR_ALREADY_ABORTED',
-  ERR_TOO_MANY_ADDRESSES = 'ERR_TOO_MANY_ADDRESSES',
-  ERR_NO_VALID_ADDRESSES = 'ERR_NO_VALID_ADDRESSES',
-  ERR_RELAYED_DIAL = 'ERR_RELAYED_DIAL',
-  ERR_DIALED_SELF = 'ERR_DIALED_SELF',
-  ERR_DISCOVERED_SELF = 'ERR_DISCOVERED_SELF',
-  ERR_DUPLICATE_TRANSPORT = 'ERR_DUPLICATE_TRANSPORT',
-  ERR_ENCRYPTION_FAILED = 'ERR_ENCRYPTION_FAILED',
-  ERR_HOP_REQUEST_FAILED = 'ERR_HOP_REQUEST_FAILED',
-  ERR_INVALID_KEY = 'ERR_INVALID_KEY',
-  ERR_INVALID_MESSAGE = 'ERR_INVALID_MESSAGE',
-  ERR_INVALID_PARAMETERS = 'ERR_INVALID_PARAMETERS',
-  ERR_INVALID_PEER = 'ERR_INVALID_PEER',
-  ERR_MUXER_UNAVAILABLE = 'ERR_MUXER_UNAVAILABLE',
-  ERR_NOT_FOUND = 'ERR_NOT_FOUND',
-  ERR_TRANSPORT_UNAVAILABLE = 'ERR_TRANSPORT_UNAVAILABLE',
-  ERR_TRANSPORT_DIAL_FAILED = 'ERR_TRANSPORT_DIAL_FAILED',
-  ERR_UNSUPPORTED_PROTOCOL = 'ERR_UNSUPPORTED_PROTOCOL',
-  ERR_PROTOCOL_HANDLER_ALREADY_REGISTERED = 'ERR_PROTOCOL_HANDLER_ALREADY_REGISTERED',
-  ERR_INVALID_MULTIADDR = 'ERR_INVALID_MULTIADDR',
-  ERR_SIGNATURE_NOT_VALID = 'ERR_SIGNATURE_NOT_VALID',
-  ERR_FIND_SELF = 'ERR_FIND_SELF',
-  ERR_NO_ROUTERS_AVAILABLE = 'ERR_NO_ROUTERS_AVAILABLE',
-  ERR_CONNECTION_NOT_MULTIPLEXED = 'ERR_CONNECTION_NOT_MULTIPLEXED',
-  ERR_NO_DIAL_TOKENS = 'ERR_NO_DIAL_TOKENS',
-  ERR_INVALID_CMS = 'ERR_INVALID_CMS',
-  ERR_MISSING_KEYS = 'ERR_MISSING_KEYS',
-  ERR_NO_KEY = 'ERR_NO_KEY',
-  ERR_INVALID_KEY_NAME = 'ERR_INVALID_KEY_NAME',
-  ERR_INVALID_KEY_TYPE = 'ERR_INVALID_KEY_TYPE',
-  ERR_KEY_ALREADY_EXISTS = 'ERR_KEY_ALREADY_EXISTS',
-  ERR_INVALID_KEY_SIZE = 'ERR_INVALID_KEY_SIZE',
-  ERR_KEY_NOT_FOUND = 'ERR_KEY_NOT_FOUND',
-  ERR_OLD_KEY_NAME_INVALID = 'ERR_OLD_KEY_NAME_INVALID',
-  ERR_NEW_KEY_NAME_INVALID = 'ERR_NEW_KEY_NAME_INVALID',
-  ERR_PASSWORD_REQUIRED = 'ERR_PASSWORD_REQUIRED',
-  ERR_PEM_REQUIRED = 'ERR_PEM_REQUIRED',
-  ERR_CANNOT_READ_KEY = 'ERR_CANNOT_READ_KEY',
-  ERR_MISSING_PRIVATE_KEY = 'ERR_MISSING_PRIVATE_KEY',
-  ERR_MISSING_PUBLIC_KEY = 'ERR_MISSING_PUBLIC_KEY',
-  ERR_INVALID_OLD_PASS_TYPE = 'ERR_INVALID_OLD_PASS_TYPE',
-  ERR_INVALID_NEW_PASS_TYPE = 'ERR_INVALID_NEW_PASS_TYPE',
-  ERR_INVALID_PASS_LENGTH = 'ERR_INVALID_PASS_LENGTH',
-  ERR_NOT_IMPLEMENTED = 'ERR_NOT_IMPLEMENTED',
-  ERR_WRONG_PING_ACK = 'ERR_WRONG_PING_ACK',
-  ERR_INVALID_RECORD = 'ERR_INVALID_RECORD',
-  ERR_ALREADY_SUCCEEDED = 'ERR_ALREADY_SUCCEEDED',
-  ERR_NO_HANDLER_FOR_PROTOCOL = 'ERR_NO_HANDLER_FOR_PROTOCOL',
-  ERR_TOO_MANY_OUTBOUND_PROTOCOL_STREAMS = 'ERR_TOO_MANY_OUTBOUND_PROTOCOL_STREAMS',
-  ERR_TOO_MANY_INBOUND_PROTOCOL_STREAMS = 'ERR_TOO_MANY_INBOUND_PROTOCOL_STREAMS',
-  ERR_CONNECTION_DENIED = 'ERR_CONNECTION_DENIED',
-  ERR_TRANSFER_LIMIT_EXCEEDED = 'ERR_TRANSFER_LIMIT_EXCEEDED'
+export class MissingServiceError extends Error {
+  constructor (message = 'Missing service') {
+    super(message)
+    this.name = 'MissingServiceError'
+  }
+}
+
+export class UnmetServiceDependenciesError extends Error {
+  constructor (message = 'Unmet service dependencies') {
+    super(message)
+    this.name = 'UnmetServiceDependenciesError'
+  }
+}
+
+export class NoContentRoutersError extends Error {
+  constructor (message = 'No content routers available') {
+    super(message)
+    this.name = 'NoContentRoutersError'
+  }
+}
+
+export class NoPeerRoutersError extends Error {
+  constructor (message = 'No peer routers available') {
+    super(message)
+    this.name = 'NoPeerRoutersError'
+  }
+}
+
+export class QueriedForSelfError extends Error {
+  constructor (message = 'Should not try to find self') {
+    super(message)
+    this.name = 'QueriedForSelfError'
+  }
+}
+
+export class UnhandledProtocolError extends Error {
+  constructor (message = 'Unhandled protocol error') {
+    super(message)
+    this.name = 'UnhandledProtocolError'
+  }
+}
+
+export class DuplicateProtocolHandlerError extends Error {
+  constructor (message = 'Duplicate protocol handler error') {
+    super(message)
+    this.name = 'DuplicateProtocolHandlerError'
+  }
+}
+
+export class DialDeniedError extends Error {
+  constructor (message = 'Dial denied error') {
+    super(message)
+    this.name = 'DialDeniedError'
+  }
+}
+
+export class NoValidAddressesError extends Error {
+  constructor (message = 'No valid addresses') {
+    super(message)
+    this.name = 'NoValidAddressesError'
+  }
+}
+
+export class ConnectionInterceptedError extends Error {
+  constructor (message = 'Connection intercepted') {
+    super(message)
+    this.name = 'ConnectionInterceptedError'
+  }
+}
+
+export class ConnectionDeniedError extends Error {
+  constructor (message = 'Connection denied') {
+    super(message)
+    this.name = 'ConnectionDeniedError'
+  }
+}
+
+export class MuxerUnavailableError extends Error {
+  constructor (message = 'Stream is not multiplexed') {
+    super(message)
+    this.name = 'MuxerUnavailableError'
+  }
+}
+
+export class EncryptionFailedError extends Error {
+  constructor (message = 'Encryption failed') {
+    super(message)
+    this.name = 'EncryptionFailedError'
+  }
+}
+
+export class TransportUnavailableError extends Error {
+  constructor (message = 'Transport unavailable') {
+    super(message)
+    this.name = 'TransportUnavailableError'
+  }
 }

package/src/get-peer.ts

@@ -1,7 +1,6 @@
-import { CodeError, isPeerId } from '@libp2p/interface'
+import { InvalidMultiaddrError, InvalidParametersError, isPeerId } from '@libp2p/interface'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { isMultiaddr } from '@multiformats/multiaddr'
-import { codes } from './errors.js'
 import type { PeerId } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
@@ -31,20 +30,20 @@ export function getPeerAddress (peer: PeerId | Multiaddr | Multiaddr[]): PeerAdd
     // ensure PeerId is either not set or is consistent
     peer.forEach(ma => {
       if (!isMultiaddr(ma)) {
-        throw new CodeError('Invalid Multiaddr', codes.ERR_INVALID_MULTIADDR)
+        throw new InvalidMultiaddrError('Invalid multiaddr')
       }
 
       const maPeerIdStr = ma.getPeerId()
 
       if (maPeerIdStr == null) {
         if (peerId != null) {
-          throw new CodeError('Multiaddrs must all have the same peer id or have no peer id', codes.ERR_INVALID_PARAMETERS)
+          throw new InvalidParametersError('Multiaddrs must all have the same peer id or have no peer id')
         }
       } else {
         const maPeerId = peerIdFromString(maPeerIdStr)
 
         if (peerId?.equals(maPeerId) !== true) {
-          throw new CodeError('Multiaddrs must all have the same peer id or have no peer id', codes.ERR_INVALID_PARAMETERS)
+          throw new InvalidParametersError('Multiaddrs must all have the same peer id or have no peer id')
         }
       }
     })

package/src/index.ts

@@ -14,13 +14,16 @@
  * ```
  */
 
-import { createLibp2pNode } from './libp2p.js'
+import { generateKeyPair } from '@libp2p/crypto/keys'
+import { peerIdFromPrivateKey } from '@libp2p/peer-id'
+import { validateConfig } from './config.js'
+import { Libp2p as Libp2pClass } from './libp2p.js'
 import type { AddressManagerInit } from './address-manager/index.js'
 import type { Components } from './components.js'
 import type { ConnectionManagerInit } from './connection-manager/index.js'
 import type { ConnectionMonitorInit } from './connection-monitor.js'
 import type { TransportManagerInit } from './transport-manager.js'
-import type { Libp2p, ServiceMap, ComponentLogger, NodeInfo, ConnectionProtector, ConnectionEncrypter, ConnectionGater, ContentRouting, Metrics, PeerDiscovery, PeerId, PeerRouting, StreamMuxerFactory, Transport, PrivateKey } from '@libp2p/interface'
+import type { Libp2p, ServiceMap, ComponentLogger, NodeInfo, ConnectionProtector, ConnectionEncrypter, ConnectionGater, ContentRouting, Metrics, PeerDiscovery, PeerRouting, StreamMuxerFactory, Transport, PrivateKey } from '@libp2p/interface'
 import type { PersistentPeerStoreInit } from '@libp2p/peer-store'
 import type { DNS } from '@multiformats/dns'
 import type { Datastore } from 'interface-datastore'
@@ -34,12 +37,11 @@ export type ServiceFactoryMap<T extends ServiceMap = ServiceMap> = {
  */
 export interface Libp2pInit<T extends ServiceMap = ServiceMap> {
   /**
-   * peerId instance (it will be created if not provided)
-   */
-  peerId?: PeerId
-
-  /**
-   * Private key associated with the peerId
+   * The private key is used in cryptographic operations and the Peer ID derived
+   * from it's corresponding public key is used to identify the node to other
+   * peers on the network.
+   *
+   * If this is not passed a new Ed25519 private key will be generated.
    */
   privateKey?: PrivateKey
 
@@ -86,13 +88,36 @@ export interface Libp2pInit<T extends ServiceMap = ServiceMap> {
   peerStore?: PersistentPeerStoreInit
 
   /**
-   * An array that must include at least 1 compliant transport
+   * Transports are low-level communication channels
    */
   transports?: Array<(components: Components) => Transport>
+
+  /**
+   * Stream muxers allow the creation of many data streams over a single
+   * connection.
+   */
   streamMuxers?: Array<(components: Components) => StreamMuxerFactory>
+
+  /**
+   * Connection encrypters ensure that data sent over connections cannot be
+   * eavesdropped on, and that the remote peer posesses the private key that
+   * corresponds to the public key that it's Peer ID is derived from.
+   */
   connectionEncryption?: Array<(components: Components) => ConnectionEncrypter>
+
+  /**
+   * Peer discovery mechanisms allow finding peers on the network
+   */
   peerDiscovery?: Array<(components: Components) => PeerDiscovery>
+
+  /**
+   * Peer routers provide implementations for peer routing queries
+   */
   peerRouters?: Array<(components: Components) => PeerRouting>
+
+  /**
+   * Content routers provide implementations for content routing queries
+   */
   contentRouters?: Array<(components: Components) => ContentRouting>
 
   /**
@@ -170,7 +195,12 @@ export type Libp2pOptions<T extends ServiceMap = ServiceMap> = Libp2pInit<T> & {
  * ```
  */
 export async function createLibp2p <T extends ServiceMap = ServiceMap> (options: Libp2pOptions<T> = {}): Promise<Libp2p<T>> {
-  const node = await createLibp2pNode(options)
+  options.privateKey ??= await generateKeyPair('Ed25519')
+
+  const node = new Libp2pClass({
+    ...await validateConfig(options),
+    peerId: peerIdFromPrivateKey(options.privateKey)
+  })
 
   if (options.start !== false) {
     await node.start()

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'
@@ -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
         }