libp2p 0.42.2 → 0.43.0

package/src/nat-manager.ts

@@ -4,7 +4,7 @@ import { fromNodeAddress } from '@multiformats/multiaddr'
 import { isBrowser } from 'wherearewe'
 import isPrivateIp from 'private-ip'
 import * as pkg from './version.js'
-import errCode from 'err-code'
+import { CodeError } from '@libp2p/interfaces/errors'
 import { codes } from './errors.js'
 import { isLoopback } from '@libp2p/utils/multiaddr/is-loopback'
 import type { Startable } from '@libp2p/interfaces/startable'
@@ -15,7 +15,7 @@ import type { AddressManager } from '@libp2p/interface-address-manager'
 const log = logger('libp2p:nat')
 const DEFAULT_TTL = 7200
 
-function highPort (min = 1024, max = 65535) {
+function highPort (min = 1024, max = 65535): number {
   return Math.floor(Math.random() * (max - min + 1) + min)
 }
 
@@ -94,22 +94,24 @@ export class NatManager implements Startable {
     this.gateway = init.gateway
 
     if (this.ttl < DEFAULT_TTL) {
-      throw errCode(new Error(`NatManager ttl should be at least ${DEFAULT_TTL} seconds`), codes.ERR_INVALID_PARAMETERS)
+      throw new CodeError(`NatManager ttl should be at least ${DEFAULT_TTL} seconds`, codes.ERR_INVALID_PARAMETERS)
     }
   }
 
-  isStarted () {
+  isStarted (): boolean {
     return this.started
   }
 
-  start () {}
+  start (): void {
+    // #TODO: is there a way to remove this? Seems like a hack
+  }
 
   /**
    * Attempt to use uPnP to configure port mapping using the current gateway.
    *
    * Run after start to ensure the transport manager has all addresses configured.
    */
-  afterStart () {
+  afterStart (): void {
     if (isBrowser || !this.enabled || this.started) {
       return
     }
@@ -123,7 +125,7 @@ export class NatManager implements Startable {
     })
   }
 
-  async _start () {
+  async _start (): Promise<void> {
     const addrs = this.components.transportManager.getAddrs()
 
     for (const addr of addrs) {
@@ -178,7 +180,7 @@ export class NatManager implements Startable {
     }
   }
 
-  async _getClient () {
+  async _getClient (): Promise<NatAPI> {
     if (this.client != null) {
       return this.client
     }
@@ -196,7 +198,7 @@ export class NatManager implements Startable {
   /**
    * Stops the NAT manager
    */
-  async stop () {
+  async stop (): Promise<void> {
     if (isBrowser || this.client == null) {
       return
     }

package/src/peer-record-updater.ts

@@ -26,18 +26,18 @@ export class PeerRecordUpdater implements Startable {
     this.update = this.update.bind(this)
   }
 
-  isStarted () {
+  isStarted (): boolean {
     return this.started
   }
 
-  async start () {
+  async start (): Promise<void> {
     this.started = true
     this.components.transportManager.addEventListener('listener:listening', this.update)
     this.components.transportManager.addEventListener('listener:close', this.update)
     this.components.addressManager.addEventListener('change:addresses', this.update)
   }
 
-  async stop () {
+  async stop (): Promise<void> {
     this.started = false
     this.components.transportManager.removeEventListener('listener:listening', this.update)
     this.components.transportManager.removeEventListener('listener:close', this.update)
@@ -47,7 +47,7 @@ export class PeerRecordUpdater implements Startable {
   /**
    * Create (or update if existing) self peer record and store it in the AddressBook.
    */
-  update () {
+  update (): void {
     Promise.resolve()
       .then(async () => {
         const peerRecord = new PeerRecord({

package/src/peer-routing.ts

@@ -1,5 +1,5 @@
 import { logger } from '@libp2p/logger'
-import errCode from 'err-code'
+import { CodeError } from '@libp2p/interfaces/errors'
 import { codes, messages } from './errors.js'
 import {
   storeAddresses,
@@ -76,14 +76,14 @@ export class DefaultPeerRouting implements PeerRouting, Startable {
     this._findClosestPeersTask = this._findClosestPeersTask.bind(this)
   }
 
-  isStarted () {
+  isStarted (): boolean {
     return this.started
   }
 
   /**
    * Start peer routing service.
    */
-  async start () {
+  async start (): Promise<void> {
     if (this.started || this.routers.length === 0 || this.timeoutId != null || this.refreshManagerInit.enabled === false) {
       return
     }
@@ -98,7 +98,7 @@ export class DefaultPeerRouting implements PeerRouting, Startable {
   /**
    * Recurrent task to find closest peers and add their addresses to the Address Book.
    */
-  async _findClosestPeersTask () {
+  async _findClosestPeersTask (): Promise<void> {
     if (this.abortController != null) {
       // we are already running the query
       return
@@ -127,7 +127,7 @@ export class DefaultPeerRouting implements PeerRouting, Startable {
   /**
    * Stop peer routing service.
    */
-  async stop () {
+  async stop (): Promise<void> {
     clearDelayedInterval(this.timeoutId)
 
     // abort query if it is in-flight
@@ -141,11 +141,11 @@ export class DefaultPeerRouting implements PeerRouting, Startable {
    */
   async findPeer (id: PeerId, options?: AbortOptions): Promise<PeerInfo> {
     if (this.routers.length === 0) {
-      throw errCode(new Error('No peer routers available'), codes.ERR_NO_ROUTERS_AVAILABLE)
+      throw new CodeError('No peer routers available', codes.ERR_NO_ROUTERS_AVAILABLE)
     }
 
     if (id.toString() === this.components.peerId.toString()) {
-      throw errCode(new Error('Should not try to find self'), codes.ERR_FIND_SELF)
+      throw new CodeError('Should not try to find self', codes.ERR_FIND_SELF)
     }
 
     const output = await pipe(
@@ -167,7 +167,7 @@ export class DefaultPeerRouting implements PeerRouting, Startable {
       return output
     }
 
-    throw errCode(new Error(messages.NOT_FOUND), codes.ERR_NOT_FOUND)
+    throw new CodeError(messages.NOT_FOUND, codes.ERR_NOT_FOUND)
   }
 
   /**
@@ -175,7 +175,7 @@ export class DefaultPeerRouting implements PeerRouting, Startable {
    */
   async * getClosestPeers (key: Uint8Array, options?: AbortOptions): AsyncIterable<PeerInfo> {
     if (this.routers.length === 0) {
-      throw errCode(new Error('No peer routers available'), codes.ERR_NO_ROUTERS_AVAILABLE)
+      throw new CodeError('No peer routers available', codes.ERR_NO_ROUTERS_AVAILABLE)
     }
 
     yield * pipe(

package/src/ping/index.ts

@@ -1,5 +1,5 @@
 import { logger } from '@libp2p/logger'
-import errCode from 'err-code'
+import { CodeError } from '@libp2p/interfaces/errors'
 import { codes } from '../errors.js'
 import { randomBytes } from '@libp2p/crypto'
 import { pipe } from 'it-pipe'
@@ -47,7 +47,7 @@ export class PingService implements Startable {
     this.init = init
   }
 
-  async start () {
+  async start (): Promise<void> {
     await this.components.registrar.handle(this.protocol, this.handleMessage, {
       maxInboundStreams: this.init.maxInboundStreams,
       maxOutboundStreams: this.init.maxOutboundStreams
@@ -55,19 +55,19 @@ export class PingService implements Startable {
     this.started = true
   }
 
-  async stop () {
+  async stop (): Promise<void> {
     await this.components.registrar.unhandle(this.protocol)
     this.started = false
   }
 
-  isStarted () {
+  isStarted (): boolean {
     return this.started
   }
 
   /**
    * A handler to register with Libp2p to process ping messages
    */
-  handleMessage (data: IncomingStreamData) {
+  handleMessage (data: IncomingStreamData): void {
     const { stream } = data
 
     void pipe(stream, stream)
@@ -119,7 +119,7 @@ export class PingService implements Startable {
       const end = Date.now()
 
       if (result == null || !uint8ArrayEquals(data, result.subarray())) {
-        throw errCode(new Error('Received wrong ping ack'), codes.ERR_WRONG_PING_ACK)
+        throw new CodeError('Received wrong ping ack', codes.ERR_WRONG_PING_ACK)
       }
 
       return end - start

package/src/pnet/crypto.ts

@@ -11,7 +11,7 @@ const log = logger('libp2p:pnet')
 /**
  * Creates a stream iterable to encrypt messages in a private network
  */
-export function createBoxStream (nonce: Uint8Array, psk: Uint8Array) {
+export function createBoxStream (nonce: Uint8Array, psk: Uint8Array): (source: Source<Uint8Array>) => AsyncIterable<Uint8Array> {
   const xor = xsalsa20(nonce, psk)
 
   return (source: Source<Uint8Array>) => (async function * () {
@@ -38,7 +38,7 @@ export function createUnboxStream (nonce: Uint8Array, psk: Uint8Array) {
 /**
  * Decode the version 1 psk from the given Uint8Array
  */
-export function decodeV1PSK (pskBuffer: Uint8Array) {
+export function decodeV1PSK (pskBuffer: Uint8Array): { tag: string | undefined, codecName: string | undefined, psk: Uint8Array } {
   try {
     // This should pull from multibase/multicodec to allow for
     // more encoding flexibility. Ideally we'd consume the codecs
@@ -58,7 +58,7 @@ export function decodeV1PSK (pskBuffer: Uint8Array) {
     return {
       tag: pskTag,
       codecName: codec,
-      psk: psk
+      psk
     }
   } catch (err: any) {
     log.error(err)

package/src/pnet/index.ts

@@ -24,7 +24,7 @@
 
 import { logger } from '@libp2p/logger'
 import { pipe } from 'it-pipe'
-import errCode from 'err-code'
+import { CodeError } from '@libp2p/interfaces/errors'
 import { duplexPair } from 'it-pair/duplex'
 import { randomBytes } from '@libp2p/crypto'
 import * as Errors from './errors.js'
@@ -81,7 +81,7 @@ class PreSharedKeyConnectionProtector implements ConnectionProtector {
     }
 
     if (connection == null) {
-      throw errCode(new Error(Errors.NO_HANDSHAKE_CONNECTION), codes.ERR_INVALID_PARAMETERS)
+      throw new CodeError(Errors.NO_HANDSHAKE_CONNECTION, codes.ERR_INVALID_PARAMETERS)
     }
 
     // Exchange nonces
@@ -94,7 +94,7 @@ class PreSharedKeyConnectionProtector implements ConnectionProtector {
     const result = await shake.reader.next(NONCE_LENGTH)
 
     if (result.value == null) {
-      throw errCode(new Error(Errors.STREAM_ENDED), codes.ERR_INVALID_PARAMETERS)
+      throw new CodeError(Errors.STREAM_ENDED, codes.ERR_INVALID_PARAMETERS)
     }
 
     const remoteNonce = result.value.slice()

package/src/pnet/key-generator.ts

@@ -8,7 +8,7 @@ import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
  * @param {Uint8Array | NodeJS.WriteStream} bytes - An object to write the psk into
  * @returns {void}
  */
-export function generateKey (bytes: Uint8Array | NodeJS.WriteStream) {
+export function generateKey (bytes: Uint8Array | NodeJS.WriteStream): void {
   const psk = uint8ArrayToString(randomBytes(KEY_LENGTH), 'base16')
   const key = uint8ArrayFromString('/key/swarm/psk/1.0.0/\n/base16/\n' + psk)
 

package/src/pubsub/dummy-pubsub.ts

@@ -1,7 +1,7 @@
 import { EventEmitter } from '@libp2p/interfaces/events'
 import type { PeerId } from '@libp2p/interface-peer-id'
 import type { PublishResult, PubSub, PubSubEvents, StrictNoSign, StrictSign, TopicValidatorFn } from '@libp2p/interface-pubsub'
-import errCode from 'err-code'
+import { CodeError } from '@libp2p/interfaces/errors'
 import { messages, codes } from '../errors.js'
 
 export class DummyPubSub extends EventEmitter<PubSubEvents> implements PubSub {
@@ -20,34 +20,34 @@ export class DummyPubSub extends EventEmitter<PubSubEvents> implements PubSub {
   }
 
   get globalSignaturePolicy (): typeof StrictSign | typeof StrictNoSign {
-    throw errCode(new Error(messages.PUBSUB_DISABLED), codes.ERR_PUBSUB_DISABLED)
+    throw new CodeError(messages.PUBSUB_DISABLED, codes.ERR_PUBSUB_DISABLED)
   }
 
   get multicodecs (): string[] {
-    throw errCode(new Error(messages.PUBSUB_DISABLED), codes.ERR_PUBSUB_DISABLED)
+    throw new CodeError(messages.PUBSUB_DISABLED, codes.ERR_PUBSUB_DISABLED)
   }
 
   getPeers (): PeerId[] {
-    throw errCode(new Error(messages.PUBSUB_DISABLED), codes.ERR_PUBSUB_DISABLED)
+    throw new CodeError(messages.PUBSUB_DISABLED, codes.ERR_PUBSUB_DISABLED)
   }
 
   getTopics (): string[] {
-    throw errCode(new Error(messages.PUBSUB_DISABLED), codes.ERR_PUBSUB_DISABLED)
+    throw new CodeError(messages.PUBSUB_DISABLED, codes.ERR_PUBSUB_DISABLED)
   }
 
   subscribe (): void {
-    throw errCode(new Error(messages.PUBSUB_DISABLED), codes.ERR_PUBSUB_DISABLED)
+    throw new CodeError(messages.PUBSUB_DISABLED, codes.ERR_PUBSUB_DISABLED)
   }
 
   unsubscribe (): void {
-    throw errCode(new Error(messages.PUBSUB_DISABLED), codes.ERR_PUBSUB_DISABLED)
+    throw new CodeError(messages.PUBSUB_DISABLED, codes.ERR_PUBSUB_DISABLED)
   }
 
   getSubscribers (): PeerId[] {
-    throw errCode(new Error(messages.PUBSUB_DISABLED), codes.ERR_PUBSUB_DISABLED)
+    throw new CodeError(messages.PUBSUB_DISABLED, codes.ERR_PUBSUB_DISABLED)
   }
 
   async publish (): Promise<PublishResult> {
-    throw errCode(new Error(messages.PUBSUB_DISABLED), codes.ERR_PUBSUB_DISABLED)
+    throw new CodeError(messages.PUBSUB_DISABLED, codes.ERR_PUBSUB_DISABLED)
   }
 }

package/src/registrar.ts

@@ -1,5 +1,5 @@
 import { logger } from '@libp2p/logger'
-import errCode from 'err-code'
+import { CodeError } from '@libp2p/interfaces/errors'
 import { codes } from './errors.js'
 import { isTopology, StreamHandlerOptions, StreamHandlerRecord } from '@libp2p/interface-registrar'
 import merge from 'merge-options'
@@ -44,24 +44,24 @@ export class DefaultRegistrar implements Registrar {
     this.components.peerStore.addEventListener('change:protocols', this._onProtocolChange)
   }
 
-  getProtocols () {
+  getProtocols (): string[] {
     return Array.from(new Set<string>([
       ...this.topologies.keys(),
       ...this.handlers.keys()
     ])).sort()
   }
 
-  getHandler (protocol: string) {
+  getHandler (protocol: string): StreamHandlerRecord {
     const handler = this.handlers.get(protocol)
 
     if (handler == null) {
-      throw errCode(new Error(`No handler registered for protocol ${protocol}`), codes.ERR_NO_HANDLER_FOR_PROTOCOL)
+      throw new CodeError(`No handler registered for protocol ${protocol}`, codes.ERR_NO_HANDLER_FOR_PROTOCOL)
     }
 
     return handler
   }
 
-  getTopologies (protocol: string) {
+  getTopologies (protocol: string): Topology[] {
     const topologies = this.topologies.get(protocol)
 
     if (topologies == null) {
@@ -78,7 +78,7 @@ export class DefaultRegistrar implements Registrar {
    */
   async handle (protocol: string, handler: StreamHandler, opts?: StreamHandlerOptions): Promise<void> {
     if (this.handlers.has(protocol)) {
-      throw errCode(new Error(`Handler already registered for protocol ${protocol}`), codes.ERR_PROTOCOL_HANDLER_ALREADY_REGISTERED)
+      throw new CodeError(`Handler already registered for protocol ${protocol}`, codes.ERR_PROTOCOL_HANDLER_ALREADY_REGISTERED)
     }
 
     const options = merge.bind({ ignoreUndefined: true })({
@@ -99,7 +99,7 @@ export class DefaultRegistrar implements Registrar {
    * Removes the handler for each protocol. The protocol
    * will no longer be supported on streams.
    */
-  async unhandle (protocols: string | string[]) {
+  async unhandle (protocols: string | string[]): Promise<void> {
     const protocolList = Array.isArray(protocols) ? protocols : [protocols]
 
     protocolList.forEach(protocol => {
@@ -116,7 +116,7 @@ export class DefaultRegistrar implements Registrar {
   async register (protocol: string, topology: Topology): Promise<string> {
     if (!isTopology(topology)) {
       log.error('topology must be an instance of interfaces/topology')
-      throw errCode(new Error('topology must be an instance of interfaces/topology'), codes.ERR_INVALID_PARAMETERS)
+      throw new CodeError('topology must be an instance of interfaces/topology', codes.ERR_INVALID_PARAMETERS)
     }
 
     // Create topology
@@ -140,7 +140,7 @@ export class DefaultRegistrar implements Registrar {
   /**
    * Unregister topology
    */
-  unregister (id: string) {
+  unregister (id: string): void {
     for (const [protocol, topologies] of this.topologies.entries()) {
       if (topologies.has(id)) {
         topologies.delete(id)
@@ -155,7 +155,7 @@ export class DefaultRegistrar implements Registrar {
   /**
    * Remove a disconnected peer from the record
    */
-  _onDisconnect (evt: CustomEvent<Connection>) {
+  _onDisconnect (evt: CustomEvent<Connection>): void {
     const connection = evt.detail
 
     void this.components.peerStore.protoBook.get(connection.remotePeer)
@@ -182,7 +182,7 @@ export class DefaultRegistrar implements Registrar {
    * On peer connected if we already have their protocols. Usually used for reconnects
    * as change:protocols event won't be emitted due to identical protocols.
    */
-  _onConnect (evt: CustomEvent<Connection>) {
+  _onConnect (evt: CustomEvent<Connection>): void {
     const connection = evt.detail
 
     void this.components.peerStore.protoBook.get(connection.remotePeer)
@@ -208,7 +208,7 @@ export class DefaultRegistrar implements Registrar {
   /**
    * Check if a new peer support the multicodecs for this topology
    */
-  _onProtocolChange (evt: CustomEvent<PeerProtocolsChangeData>) {
+  _onProtocolChange (evt: CustomEvent<PeerProtocolsChangeData>): void {
     const { peerId, protocols, oldProtocols } = evt.detail
     const removed = oldProtocols.filter(protocol => !protocols.includes(protocol))
     const added = protocols.filter(protocol => !oldProtocols.includes(protocol))

package/src/transport-manager.ts

@@ -1,7 +1,6 @@
 import { logger } from '@libp2p/logger'
-import pSettle from 'p-settle'
 import { codes } from './errors.js'
-import errCode from 'err-code'
+import { CodeError } from '@libp2p/interfaces/errors'
 import { FaultTolerance } from '@libp2p/interface-transport'
 import type { Listener, Transport, TransportManager, TransportManagerEvents, Upgrader } from '@libp2p/interface-transport'
 import type { Multiaddr } from '@multiformats/multiaddr'
@@ -48,15 +47,15 @@ export class DefaultTransportManager extends EventEmitter<TransportManagerEvents
   /**
    * Adds a `Transport` to the manager
    */
-  add (transport: Transport) {
+  add (transport: Transport): void {
     const tag = transport[Symbol.toStringTag]
 
     if (tag == null) {
-      throw errCode(new Error('Transport must have a valid tag'), codes.ERR_INVALID_KEY)
+      throw new CodeError('Transport must have a valid tag', codes.ERR_INVALID_KEY)
     }
 
     if (this.transports.has(tag)) {
-      throw errCode(new Error('There is already a transport with this tag'), codes.ERR_DUPLICATE_TRANSPORT)
+      throw new CodeError(`There is already a transport with the tag ${tag}`, codes.ERR_DUPLICATE_TRANSPORT)
     }
 
     log('adding transport %s', tag)
@@ -68,11 +67,11 @@ export class DefaultTransportManager extends EventEmitter<TransportManagerEvents
     }
   }
 
-  isStarted () {
+  isStarted (): boolean {
     return this.started
   }
 
-  async start () {
+  async start (): Promise<void> {
     // Listen on the provided transports for the provided addresses
     const addrs = this.components.addressManager.getListenAddrs()
 
@@ -84,7 +83,7 @@ export class DefaultTransportManager extends EventEmitter<TransportManagerEvents
   /**
    * Stops all listeners
    */
-  async stop () {
+  async stop (): Promise<void> {
     const tasks = []
     for (const [key, listeners] of this.listeners) {
       log('closing listeners for %s', key)
@@ -115,7 +114,7 @@ export class DefaultTransportManager extends EventEmitter<TransportManagerEvents
     const transport = this.transportForMultiaddr(ma)
 
     if (transport == null) {
-      throw errCode(new Error(`No transport available for address ${String(ma)}`), codes.ERR_TRANSPORT_UNAVAILABLE)
+      throw new CodeError(`No transport available for address ${String(ma)}`, codes.ERR_TRANSPORT_UNAVAILABLE)
     }
 
     try {
@@ -148,14 +147,14 @@ export class DefaultTransportManager extends EventEmitter<TransportManagerEvents
   /**
    * Returns all the transports instances
    */
-  getTransports () {
+  getTransports (): Transport[] {
     return Array.of(...this.transports.values())
   }
 
   /**
    * Finds a transport that matches the given Multiaddr
    */
-  transportForMultiaddr (ma: Multiaddr) {
+  transportForMultiaddr (ma: Multiaddr): Transport | undefined {
     for (const transport of this.transports.values()) {
       const addrs = transport.filter([ma])
 
@@ -168,7 +167,7 @@ export class DefaultTransportManager extends EventEmitter<TransportManagerEvents
   /**
    * Starts listeners for each listen Multiaddr
    */
-  async listen (addrs: Multiaddr[]) {
+  async listen (addrs: Multiaddr[]): Promise<void> {
     if (addrs == null || addrs.length === 0) {
       log('no addresses were provided for listening, this node is dial only')
       return
@@ -218,14 +217,14 @@ export class DefaultTransportManager extends EventEmitter<TransportManagerEvents
         continue
       }
 
-      const results = await pSettle(tasks)
+      const results = await Promise.allSettled(tasks)
       // If we are listening on at least 1 address, succeed.
       // TODO: we should look at adding a retry (`p-retry`) here to better support
       // listening on remote addresses as they may be offline. We could then potentially
       // just wait for any (`p-any`) listener to succeed on each transport before returning
-      const isListening = results.find(r => r.isFulfilled)
+      const isListening = results.find(r => r.status === 'fulfilled')
       if ((isListening == null) && this.faultTolerance !== FaultTolerance.NO_FATAL) {
-        throw errCode(new Error(`Transport (${key}) could not listen on any available address`), codes.ERR_NO_VALID_ADDRESSES)
+        throw new CodeError(`Transport (${key}) could not listen on any available address`, codes.ERR_NO_VALID_ADDRESSES)
       }
     }
 
@@ -234,7 +233,7 @@ export class DefaultTransportManager extends EventEmitter<TransportManagerEvents
     if (couldNotListen.length === this.transports.size) {
       const message = `no valid addresses were provided for transports [${couldNotListen.join(', ')}]`
       if (this.faultTolerance === FaultTolerance.FATAL_ALL) {
-        throw errCode(new Error(message), codes.ERR_NO_VALID_ADDRESSES)
+        throw new CodeError(message, codes.ERR_NO_VALID_ADDRESSES)
       }
       log(`libp2p in dial mode only: ${message}`)
     }
@@ -244,7 +243,7 @@ export class DefaultTransportManager extends EventEmitter<TransportManagerEvents
    * Removes the given transport from the manager.
    * If a transport has any running listeners, they will be closed.
    */
-  async remove (key: string) {
+  async remove (key: string): Promise<void> {
     log('removing %s', key)
 
     // Close any running listeners
@@ -262,7 +261,7 @@ export class DefaultTransportManager extends EventEmitter<TransportManagerEvents
    *
    * @async
    */
-  async removeAll () {
+  async removeAll (): Promise<void> {
     const tasks = []
     for (const key of this.transports.keys()) {
       tasks.push(this.remove(key))