libp2p 0.42.2 → 0.43.0

package/src/connection-manager/visibility-change-emitter.ts

@@ -60,7 +60,7 @@ export class VisibilityChangeEmitter extends EventEmitter<VisibilityChangeEmitte
    *
    * @private
    */
-  _initializeVisibilityVarNames () {
+  _initializeVisibilityVarNames (): void {
     let hidden: Hidden = 'hidden'
     let visibilityChange = 'visibilitychange'
 
@@ -91,7 +91,7 @@ export class VisibilityChangeEmitter extends EventEmitter<VisibilityChangeEmitte
    *
    * @private
    */
-  _addVisibilityChangeListener () {
+  _addVisibilityChangeListener (): void {
     // @ts-expect-error cannot index document object with string key
     if (typeof globalThis.document.addEventListener === 'undefined' || typeof document[this.hidden] === 'undefined') {
       log('Checking page visibility requires a browser that supports the Page Visibility API.')
@@ -105,7 +105,7 @@ export class VisibilityChangeEmitter extends EventEmitter<VisibilityChangeEmitte
    * The function returns ```true``` if the page is visible or ```false``` if the page is not visible and
    * ```undefined``` if the page visibility API is not supported by the browser.
    */
-  isVisible () {
+  isVisible (): boolean | undefined {
     // @ts-expect-error cannot index document object with string key
     if (this.hidden === undefined || document[this.hidden] === undefined) {
       return undefined
@@ -122,7 +122,7 @@ export class VisibilityChangeEmitter extends EventEmitter<VisibilityChangeEmitte
    *
    * @private
    */
-  _handleVisibilityChange () {
+  _handleVisibilityChange (): void {
     // @ts-expect-error cannot index document object with string key
     const visible = globalThis.document[this.hidden] === false
     log(visible ? 'Page Visible' : 'Page Hidden')

package/src/content-routing/index.ts

@@ -1,4 +1,4 @@
-import errCode from 'err-code'
+import { CodeError } from '@libp2p/interfaces/errors'
 import { messages, codes } from '../errors.js'
 import {
   storeAddresses,
@@ -14,6 +14,8 @@ import type { Startable } from '@libp2p/interfaces/startable'
 import type { CID } from 'multiformats/cid'
 import type { PeerStore } from '@libp2p/interface-peer-store'
 import type { DualDHT } from '@libp2p/interface-dht'
+import type { PeerInfo } from '@libp2p/interface-peer-info'
+import type { PeerId } from '@libp2p/interface-peer-id'
 
 export interface CompoundContentRoutingInit {
   routers: ContentRouting[]
@@ -35,24 +37,24 @@ export class CompoundContentRouting implements ContentRouting, Startable {
     this.components = components
   }
 
-  isStarted () {
+  isStarted (): boolean {
     return this.started
   }
 
-  async start () {
+  async start (): Promise<void> {
     this.started = true
   }
 
-  async stop () {
+  async stop (): Promise<void> {
     this.started = false
   }
 
   /**
    * Iterates over all content routers in parallel to find providers of the given key
    */
-  async * findProviders (key: CID, options: AbortOptions = {}) {
+  async * findProviders (key: CID, options: AbortOptions = {}): AsyncIterable<PeerInfo> {
     if (this.routers.length === 0) {
-      throw errCode(new Error('No content this.routers available'), codes.ERR_NO_ROUTERS_AVAILABLE)
+      throw new CodeError('No content this.routers available', codes.ERR_NO_ROUTERS_AVAILABLE)
     }
 
     yield * pipe(
@@ -69,20 +71,20 @@ export class CompoundContentRouting implements ContentRouting, Startable {
    * Iterates over all content routers in parallel to notify it is
    * a provider of the given key
    */
-  async provide (key: CID, options: AbortOptions = {}) {
+  async provide (key: CID, options: AbortOptions = {}): Promise<void> {
     if (this.routers.length === 0) {
-      throw errCode(new Error('No content routers available'), codes.ERR_NO_ROUTERS_AVAILABLE)
+      throw new CodeError('No content routers available', codes.ERR_NO_ROUTERS_AVAILABLE)
     }
 
-    await Promise.all(this.routers.map(async (router) => await router.provide(key, options)))
+    await Promise.all(this.routers.map(async (router) => { await router.provide(key, options) }))
   }
 
   /**
    * Store the given key/value pair in the available content routings
    */
-  async put (key: Uint8Array, value: Uint8Array, options?: AbortOptions) {
+  async put (key: Uint8Array, value: Uint8Array, options?: AbortOptions): Promise<void> {
     if (!this.isStarted()) {
-      throw errCode(new Error(messages.NOT_STARTED_YET), codes.DHT_NOT_STARTED)
+      throw new CodeError(messages.NOT_STARTED_YET, codes.DHT_NOT_STARTED)
     }
 
     const dht = this.components.dht
@@ -98,7 +100,7 @@ export class CompoundContentRouting implements ContentRouting, Startable {
    */
   async get (key: Uint8Array, options?: AbortOptions): Promise<Uint8Array> {
     if (!this.isStarted()) {
-      throw errCode(new Error(messages.NOT_STARTED_YET), codes.DHT_NOT_STARTED)
+      throw new CodeError(messages.NOT_STARTED_YET, codes.DHT_NOT_STARTED)
     }
 
     const dht = this.components.dht
@@ -111,15 +113,15 @@ export class CompoundContentRouting implements ContentRouting, Startable {
       }
     }
 
-    throw errCode(new Error(messages.NOT_FOUND), codes.ERR_NOT_FOUND)
+    throw new CodeError(messages.NOT_FOUND, codes.ERR_NOT_FOUND)
   }
 
   /**
    * Get the `n` values to the given key without sorting
    */
-  async * getMany (key: Uint8Array, nVals: number, options: AbortOptions) { // eslint-disable-line require-await
+  async * getMany (key: Uint8Array, nVals: number, options: AbortOptions): AsyncIterable<{ from: PeerId, val: Uint8Array }> {
     if (!this.isStarted()) {
-      throw errCode(new Error(messages.NOT_STARTED_YET), codes.DHT_NOT_STARTED)
+      throw new CodeError(messages.NOT_STARTED_YET, codes.DHT_NOT_STARTED)
     }
 
     if (nVals == null || nVals === 0) {
@@ -144,7 +146,7 @@ export class CompoundContentRouting implements ContentRouting, Startable {
     }
 
     if (gotValues === 0) {
-      throw errCode(new Error(messages.NOT_FOUND), codes.ERR_NOT_FOUND)
+      throw new CodeError(messages.NOT_FOUND, codes.ERR_NOT_FOUND)
     }
   }
 }

package/src/content-routing/utils.ts

@@ -1,4 +1,4 @@
-import errCode from 'err-code'
+import { CodeError } from '@libp2p/interfaces/errors'
 import filter from 'it-filter'
 import map from 'it-map'
 import type { Source } from 'it-stream-types'
@@ -8,7 +8,7 @@ import type { PeerStore } from '@libp2p/interface-peer-store'
 /**
  * Store the multiaddrs from every peer in the passed peer store
  */
-export async function * storeAddresses (source: Source<PeerInfo>, peerStore: PeerStore) {
+export async function * storeAddresses (source: Source<PeerInfo>, peerStore: PeerStore): AsyncIterable<PeerInfo> {
   yield * map(source, async (peer) => {
     // ensure we have the addresses for a given peer
     await peerStore.addressBook.add(peer.id, peer.multiaddrs)
@@ -20,7 +20,7 @@ export async function * storeAddresses (source: Source<PeerInfo>, peerStore: Pee
 /**
  * Filter peers by unique peer id
  */
-export function uniquePeers (source: Source<PeerInfo>) {
+export function uniquePeers (source: Source<PeerInfo>): AsyncIterable<PeerInfo> {
   /** @type Set<string> */
   const seen = new Set()
 
@@ -39,7 +39,7 @@ export function uniquePeers (source: Source<PeerInfo>) {
 /**
  * Require at least `min` peers to be yielded from `source`
  */
-export async function * requirePeers (source: Source<PeerInfo>, min: number = 1) {
+export async function * requirePeers (source: Source<PeerInfo>, min: number = 1): AsyncIterable<PeerInfo> {
   let seen = 0
 
   for await (const peer of source) {
@@ -49,6 +49,6 @@ export async function * requirePeers (source: Source<PeerInfo>, min: number = 1)
   }
 
   if (seen < min) {
-    throw errCode(new Error('not found'), 'NOT_FOUND')
+    throw new CodeError('not found', 'NOT_FOUND')
   }
 }

package/src/dht/dht-content-routing.ts

@@ -1,9 +1,10 @@
 import drain from 'it-drain'
-import errCode from 'err-code'
+import { CodeError } from '@libp2p/interfaces/errors'
 import type { DHT } from '@libp2p/interface-dht'
 import type { ContentRouting } from '@libp2p/interface-content-routing'
 import type { CID } from 'multiformats/cid'
 import type { AbortOptions } from '@libp2p/interfaces'
+import type { PeerInfo } from '@libp2p/interface-peer-info'
 
 /**
  * Wrapper class to convert events into returned values
@@ -15,11 +16,11 @@ export class DHTContentRouting implements ContentRouting {
     this.dht = dht
   }
 
-  async provide (cid: CID) {
+  async provide (cid: CID): Promise<void> {
     await drain(this.dht.provide(cid))
   }
 
-  async * findProviders (cid: CID, options: AbortOptions = {}) {
+  async * findProviders (cid: CID, options: AbortOptions = {}): AsyncGenerator<PeerInfo, void, undefined> {
     for await (const event of this.dht.findProviders(cid, options)) {
       if (event.name === 'PROVIDER') {
         yield * event.providers
@@ -38,6 +39,6 @@ export class DHTContentRouting implements ContentRouting {
       }
     }
 
-    throw errCode(new Error('Not found'), 'ERR_NOT_FOUND')
+    throw new CodeError('Not found', 'ERR_NOT_FOUND')
   }
 }

package/src/dht/dht-peer-routing.ts

@@ -1,9 +1,10 @@
-import errCode from 'err-code'
+import { CodeError } from '@libp2p/interfaces/errors'
 import { messages, codes } from '../errors.js'
 import type { PeerRouting } from '@libp2p/interface-peer-routing'
 import type { DHT } from '@libp2p/interface-dht'
 import type { PeerId } from '@libp2p/interface-peer-id'
 import type { AbortOptions } from '@libp2p/interfaces'
+import type { PeerInfo } from '@libp2p/interface-peer-info'
 
 /**
  * Wrapper class to convert events into returned values
@@ -15,17 +16,17 @@ export class DHTPeerRouting implements PeerRouting {
     this.dht = dht
   }
 
-  async findPeer (peerId: PeerId, options: AbortOptions = {}) {
+  async findPeer (peerId: PeerId, options: AbortOptions = {}): Promise<PeerInfo> {
     for await (const event of this.dht.findPeer(peerId, options)) {
       if (event.name === 'FINAL_PEER') {
         return event.peer
       }
     }
 
-    throw errCode(new Error(messages.NOT_FOUND), codes.ERR_NOT_FOUND)
+    throw new CodeError(messages.NOT_FOUND, codes.ERR_NOT_FOUND)
   }
 
-  async * getClosestPeers (key: Uint8Array, options: AbortOptions = {}) {
+  async * getClosestPeers (key: Uint8Array, options: AbortOptions = {}): AsyncIterable<PeerInfo> {
     for await (const event of this.dht.getClosestPeers(key, options)) {
       if (event.name === 'FINAL_PEER') {
         yield event.peer

package/src/dht/dummy-dht.ts

@@ -1,6 +1,6 @@
 import type { DualDHT, QueryEvent, SingleDHT } from '@libp2p/interface-dht'
 import type { PeerDiscoveryEvents } from '@libp2p/interface-peer-discovery'
-import errCode from 'err-code'
+import { CodeError } from '@libp2p/interfaces/errors'
 import { messages, codes } from '../errors.js'
 import { EventEmitter } from '@libp2p/interfaces/events'
 import { symbol } from '@libp2p/interface-peer-discovery'
@@ -10,51 +10,51 @@ export class DummyDHT extends EventEmitter<PeerDiscoveryEvents> implements DualD
     return true
   }
 
-  get [Symbol.toStringTag] () {
+  get [Symbol.toStringTag] (): '@libp2p/dummy-dht' {
     return '@libp2p/dummy-dht'
   }
 
   get wan (): SingleDHT {
-    throw errCode(new Error(messages.DHT_DISABLED), codes.DHT_DISABLED)
+    throw new CodeError(messages.DHT_DISABLED, codes.DHT_DISABLED)
   }
 
   get lan (): SingleDHT {
-    throw errCode(new Error(messages.DHT_DISABLED), codes.DHT_DISABLED)
+    throw new CodeError(messages.DHT_DISABLED, codes.DHT_DISABLED)
   }
 
   get (): AsyncIterable<QueryEvent> {
-    throw errCode(new Error(messages.DHT_DISABLED), codes.DHT_DISABLED)
+    throw new CodeError(messages.DHT_DISABLED, codes.DHT_DISABLED)
   }
 
   findProviders (): AsyncIterable<QueryEvent> {
-    throw errCode(new Error(messages.DHT_DISABLED), codes.DHT_DISABLED)
+    throw new CodeError(messages.DHT_DISABLED, codes.DHT_DISABLED)
   }
 
   findPeer (): AsyncIterable<QueryEvent> {
-    throw errCode(new Error(messages.DHT_DISABLED), codes.DHT_DISABLED)
+    throw new CodeError(messages.DHT_DISABLED, codes.DHT_DISABLED)
   }
 
   getClosestPeers (): AsyncIterable<QueryEvent> {
-    throw errCode(new Error(messages.DHT_DISABLED), codes.DHT_DISABLED)
+    throw new CodeError(messages.DHT_DISABLED, codes.DHT_DISABLED)
   }
 
   provide (): AsyncIterable<QueryEvent> {
-    throw errCode(new Error(messages.DHT_DISABLED), codes.DHT_DISABLED)
+    throw new CodeError(messages.DHT_DISABLED, codes.DHT_DISABLED)
   }
 
   put (): AsyncIterable<QueryEvent> {
-    throw errCode(new Error(messages.DHT_DISABLED), codes.DHT_DISABLED)
+    throw new CodeError(messages.DHT_DISABLED, codes.DHT_DISABLED)
   }
 
   async getMode (): Promise<'client' | 'server'> {
-    throw errCode(new Error(messages.DHT_DISABLED), codes.DHT_DISABLED)
+    throw new CodeError(messages.DHT_DISABLED, codes.DHT_DISABLED)
   }
 
   async setMode (): Promise<void> {
-    throw errCode(new Error(messages.DHT_DISABLED), codes.DHT_DISABLED)
+    throw new CodeError(messages.DHT_DISABLED, codes.DHT_DISABLED)
   }
 
   async refreshRoutingTable (): Promise<void> {
-    throw errCode(new Error(messages.DHT_DISABLED), codes.DHT_DISABLED)
+    throw new CodeError(messages.DHT_DISABLED, codes.DHT_DISABLED)
   }
 }

package/src/errors.ts

@@ -74,5 +74,6 @@ export enum codes {
   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_CONNECTION_DENIED = 'ERR_CONNECTION_DENIED',
+  ERR_TRANSFER_LIMIT_EXCEEDED = 'ERR_TRANSFER_LIMIT_EXCEEDED',
 }

package/src/fetch/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 * as lp from 'it-length-prefixed'
 import { FetchRequest, FetchResponse } from './pb/proto.js'
@@ -67,7 +67,7 @@ export class FetchService implements Startable {
     this.init = init
   }
 
-  async start () {
+  async start (): Promise<void> {
     await this.components.registrar.handle(this.protocol, (data) => {
       void this.handleMessage(data)
         .catch(err => {
@@ -83,12 +83,12 @@ export class FetchService 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
   }
 
@@ -134,7 +134,7 @@ export class FetchService implements Startable {
           const buf = await first(source)
 
           if (buf == null) {
-            throw errCode(new Error('No data received'), codes.ERR_INVALID_MESSAGE)
+            throw new CodeError('No data received', codes.ERR_INVALID_MESSAGE)
           }
 
           const response = FetchResponse.decode(buf)
@@ -151,11 +151,11 @@ export class FetchService implements Startable {
             case (FetchResponse.StatusCode.ERROR): {
               log('received status for %s error', key)
               const errmsg = uint8arrayToString(response.data)
-              throw errCode(new Error('Error in fetch protocol response: ' + errmsg), codes.ERR_INVALID_PARAMETERS)
+              throw new CodeError('Error in fetch protocol response: ' + errmsg, codes.ERR_INVALID_PARAMETERS)
             }
             default: {
               log('received status for %s unknown', key)
-              throw errCode(new Error('Unknown response status'), codes.ERR_INVALID_MESSAGE)
+              throw new CodeError('Unknown response status', codes.ERR_INVALID_MESSAGE)
             }
           }
         }
@@ -178,7 +178,7 @@ export class FetchService implements Startable {
    * responds based on looking up the key in the request via the lookup callback that corresponds
    * to the key's prefix.
    */
-  async handleMessage (data: IncomingStreamData) {
+  async handleMessage (data: IncomingStreamData): Promise<void> {
     const { stream } = data
     const self = this
 
@@ -189,7 +189,7 @@ export class FetchService implements Startable {
         const buf = await first(source)
 
         if (buf == null) {
-          throw errCode(new Error('No data received'), codes.ERR_INVALID_MESSAGE)
+          throw new CodeError('No data received', codes.ERR_INVALID_MESSAGE)
         }
 
         // for await (const buf of source) {
@@ -224,7 +224,7 @@ export class FetchService implements Startable {
    * Given a key, finds the appropriate function for looking up its corresponding value, based on
    * the key's prefix.
    */
-  _getLookupFunction (key: string) {
+  _getLookupFunction (key: string): LookupFunction | undefined {
     for (const prefix of this.lookupFunctions.keys()) {
       if (key.startsWith(prefix)) {
         return this.lookupFunctions.get(prefix)
@@ -243,9 +243,9 @@ export class FetchService implements Startable {
    * libp2p.fetchService.registerLookupFunction('/prefix', (key) => { ... })
    * ```
    */
-  registerLookupFunction (prefix: string, lookup: LookupFunction) {
+  registerLookupFunction (prefix: string, lookup: LookupFunction): void {
     if (this.lookupFunctions.has(prefix)) {
-      throw errCode(new Error("Fetch protocol handler for key prefix '" + prefix + "' already registered"), codes.ERR_KEY_ALREADY_EXISTS)
+      throw new CodeError(`Fetch protocol handler for key prefix '${prefix}' already registered`, codes.ERR_KEY_ALREADY_EXISTS)
     }
 
     this.lookupFunctions.set(prefix, lookup)
@@ -262,7 +262,7 @@ export class FetchService implements Startable {
    * libp2p.fetchService.unregisterLookupFunction('/prefix')
    * ```
    */
-  unregisterLookupFunction (prefix: string, lookup?: LookupFunction) {
+  unregisterLookupFunction (prefix: string, lookup?: LookupFunction): void {
     if (lookup != null) {
       const existingLookup = this.lookupFunctions.get(prefix)
 

package/src/fetch/pb/proto.ts

@@ -2,10 +2,11 @@
 /* eslint-disable complexity */
 /* eslint-disable @typescript-eslint/no-namespace */
 /* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
+/* eslint-disable @typescript-eslint/no-empty-interface */
 
 import { encodeMessage, decodeMessage, message, enumeration } from 'protons-runtime'
-import type { Uint8ArrayList } from 'uint8arraylist'
 import type { Codec } from 'protons-runtime'
+import type { Uint8ArrayList } from 'uint8arraylist'
 
 export interface FetchRequest {
   identifier: string
@@ -21,7 +22,7 @@ export namespace FetchRequest {
           w.fork()
         }
 
-        if (opts.writeDefaults === true || obj.identifier !== '') {
+        if ((obj.identifier != null && obj.identifier !== '')) {
           w.uint32(10)
           w.string(obj.identifier)
         }
@@ -56,7 +57,7 @@ export namespace FetchRequest {
     return _codec
   }
 
-  export const encode = (obj: FetchRequest): Uint8Array => {
+  export const encode = (obj: Partial<FetchRequest>): Uint8Array => {
     return encodeMessage(obj, FetchRequest.codec())
   }
 
@@ -84,7 +85,7 @@ export namespace FetchResponse {
   }
 
   export namespace StatusCode {
-    export const codec = () => {
+    export const codec = (): Codec<StatusCode> => {
       return enumeration<StatusCode>(__StatusCodeValues)
     }
   }
@@ -98,12 +99,12 @@ export namespace FetchResponse {
           w.fork()
         }
 
-        if (opts.writeDefaults === true || (obj.status != null && __StatusCodeValues[obj.status] !== 0)) {
+        if (obj.status != null && __StatusCodeValues[obj.status] !== 0) {
           w.uint32(8)
           FetchResponse.StatusCode.codec().encode(obj.status, w)
         }
 
-        if (opts.writeDefaults === true || (obj.data != null && obj.data.byteLength > 0)) {
+        if ((obj.data != null && obj.data.byteLength > 0)) {
           w.uint32(18)
           w.bytes(obj.data)
         }
@@ -142,7 +143,7 @@ export namespace FetchResponse {
     return _codec
   }
 
-  export const encode = (obj: FetchResponse): Uint8Array => {
+  export const encode = (obj: Partial<FetchResponse>): Uint8Array => {
     return encodeMessage(obj, FetchResponse.codec())
   }
 

package/src/get-peer.ts

@@ -1,7 +1,7 @@
 import { peerIdFromString } from '@libp2p/peer-id'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import { isMultiaddr } from '@multiformats/multiaddr'
-import errCode from 'err-code'
+import { CodeError } from '@libp2p/interfaces/errors'
 import { codes } from './errors.js'
 import { isPeerId } from '@libp2p/interface-peer-id'
 import type { PeerId } from '@libp2p/interface-peer-id'
@@ -25,8 +25,8 @@ export function getPeerAddress (peer: PeerId | Multiaddr): { peerId?: PeerId, mu
     }
   }
 
-  throw errCode(
-    new Error(`${peer} is not a PeerId or a Multiaddr`), // eslint-disable-line @typescript-eslint/restrict-template-expressions
+  throw new CodeError(
+    `${peer} is not a PeerId or a Multiaddr`, // eslint-disable-line @typescript-eslint/restrict-template-expressions
     codes.ERR_INVALID_MULTIADDR
   )
 }