libp2p 0.36.2 → 0.37.0

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

@@ -0,0 +1,43 @@
+import drain from 'it-drain'
+import errCode from 'err-code'
+import type { DHT } from '@libp2p/interfaces/dht'
+import type { ContentRouting } from '@libp2p/interfaces/content-routing'
+import type { CID } from 'multiformats/cid'
+import type { AbortOptions } from '@libp2p/interfaces'
+
+/**
+ * Wrapper class to convert events into returned values
+ */
+export class DHTContentRouting implements ContentRouting {
+  private readonly dht: DHT
+
+  constructor (dht: DHT) {
+    this.dht = dht
+  }
+
+  async provide (cid: CID) {
+    await drain(this.dht.provide(cid))
+  }
+
+  async * findProviders (cid: CID, options: AbortOptions = {}) {
+    for await (const event of this.dht.findProviders(cid, options)) {
+      if (event.name === 'PROVIDER') {
+        yield * event.providers
+      }
+    }
+  }
+
+  async put (key: Uint8Array, value: Uint8Array, options?: AbortOptions): Promise<void> {
+    await drain(this.dht.put(key, value, options))
+  }
+
+  async get (key: Uint8Array, options?: AbortOptions): Promise<Uint8Array> {
+    for await (const event of this.dht.get(key, options)) {
+      if (event.name === 'VALUE') {
+        return event.value
+      }
+    }
+
+    throw errCode(new Error('Not found'), 'ERR_NOT_FOUND')
+  }
+}

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

@@ -0,0 +1,35 @@
+import errCode from 'err-code'
+import { messages, codes } from '../errors.js'
+import type { PeerRouting } from '@libp2p/interfaces/peer-routing'
+import type { DHT } from '@libp2p/interfaces/dht'
+import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { AbortOptions } from '@libp2p/interfaces'
+
+/**
+ * Wrapper class to convert events into returned values
+ */
+export class DHTPeerRouting implements PeerRouting {
+  private readonly dht: DHT
+
+  constructor (dht: DHT) {
+    this.dht = dht
+  }
+
+  async findPeer (peerId: PeerId, options: AbortOptions = {}) {
+    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)
+  }
+
+  async * getClosestPeers (key: Uint8Array, options: AbortOptions = {}) {
+    for await (const event of this.dht.getClosestPeers(key, options)) {
+      if (event.name === 'PEER_RESPONSE') {
+        yield * event.closer
+      }
+    }
+  }
+}

package/src/dht/dummy-dht.ts

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

package/src/errors.ts

@@ -0,0 +1,73 @@
+export enum messages {
+  NOT_STARTED_YET = 'The libp2p node is not started yet',
+  DHT_DISABLED = 'DHT is not available',
+  PUBSUB_DISABLED = 'PubSub is not available',
+  CONN_ENCRYPTION_REQUIRED = 'At least one connection encryption module is required',
+  ERR_TRANSPORTS_REQUIRED = 'At least one transport module is required',
+  ERR_PROTECTOR_REQUIRED = 'Private network is enforced, but no protector was provided',
+  NOT_FOUND = 'Not found'
+}
+
+export enum codes {
+  DHT_DISABLED = 'ERR_DHT_DISABLED',
+  ERR_PUBSUB_DISABLED = 'ERR_PUBSUB_DISABLED',
+  PUBSUB_NOT_STARTED = 'ERR_PUBSUB_NOT_STARTED',
+  DHT_NOT_STARTED = 'ERR_DHT_NOT_STARTED',
+  CONN_ENCRYPTION_REQUIRED = 'ERR_CONN_ENCRYPTION_REQUIRED',
+  ERR_TRANSPORTS_REQUIRED = 'ERR_TRANSPORTS_REQUIRED',
+  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_TIMEOUT = 'ERR_TIMEOUT',
+  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_KEYCHAIN_REQUIRED = 'ERR_KEYCHAIN_REQUIRED',
+  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'
+}

package/src/fetch/README.md

@@ -12,7 +12,7 @@ The fetch protocol is a simple protocol for requesting a value corresponding to
 ## Usage
 
 ```javascript
-const Libp2p = require('libp2p')
+import { createLibp2p } from 'libp2p'
 
 /**
  * Given a key (as a string) returns a value (as a Uint8Array), or null if the key isn't found.

package/src/fetch/constants.ts

@@ -0,0 +1,3 @@
+
+// https://github.com/libp2p/specs/tree/master/fetch#wire-protocol
+export const PROTOCOL = '/libp2p/fetch/0.0.1'

package/src/fetch/index.ts

@@ -0,0 +1,167 @@
+import { logger } from '@libp2p/logger'
+import errCode from 'err-code'
+import { codes } from '../errors.js'
+import * as lp from 'it-length-prefixed'
+import { FetchRequest, FetchResponse } from './pb/proto.js'
+import { handshake } from 'it-handshake'
+import { PROTOCOL } from './constants.js'
+import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { Startable } from '@libp2p/interfaces/startable'
+import type { Stream } from '@libp2p/interfaces/connection'
+import type { IncomingStreamData } from '@libp2p/interfaces/registrar'
+import type { Components } from '@libp2p/interfaces/components'
+
+const log = logger('libp2p:fetch')
+
+export interface FetchInit {
+  protocolPrefix: string
+}
+
+export interface HandleMessageOptions {
+  stream: Stream
+  protocol: string
+}
+
+export interface LookupFunction {
+  (key: string): Promise<Uint8Array | null>
+}
+
+/**
+ * A simple libp2p protocol for requesting a value corresponding to a key from a peer.
+ * Developers can register one or more lookup function for retrieving the value corresponding to
+ * a given key.  Each lookup function must act on a distinct part of the overall key space, defined
+ * by a fixed prefix that all keys that should be routed to that lookup function will start with.
+ */
+export class FetchService implements Startable {
+  private readonly components: Components
+  private readonly lookupFunctions: Map<string, LookupFunction>
+  private readonly protocol: string
+  private started: boolean
+
+  constructor (components: Components, init: FetchInit) {
+    this.started = false
+    this.components = components
+    this.protocol = PROTOCOL
+    this.lookupFunctions = new Map() // Maps key prefix to value lookup function
+    this.handleMessage = this.handleMessage.bind(this)
+  }
+
+  async start () {
+    await this.components.getRegistrar().handle(this.protocol, (data) => {
+      void this.handleMessage(data).catch(err => {
+        log.error(err)
+      })
+    })
+    this.started = true
+  }
+
+  async stop () {
+    await this.components.getRegistrar().unhandle(this.protocol)
+    this.started = false
+  }
+
+  isStarted () {
+    return this.started
+  }
+
+  /**
+   * Sends a request to fetch the value associated with the given key from the given peer
+   */
+  async fetch (peer: PeerId, key: string): Promise<Uint8Array | null> {
+    log('dialing %s to %p', this.protocol, peer)
+
+    const connection = await this.components.getConnectionManager().openConnection(peer)
+    const { stream } = await connection.newStream([this.protocol])
+    const shake = handshake(stream)
+
+    // send message
+    shake.write(lp.encode.single(FetchRequest.encode({ identifier: key })).slice())
+
+    // read response
+    // @ts-expect-error fromReader returns a Source which has no .next method
+    const response = FetchResponse.decode((await lp.decode.fromReader(shake.reader).next()).value.slice())
+    switch (response.status) {
+      case (FetchResponse.StatusCode.OK): {
+        return response.data
+      }
+      case (FetchResponse.StatusCode.NOT_FOUND): {
+        return null
+      }
+      case (FetchResponse.StatusCode.ERROR): {
+        const errmsg = (new TextDecoder()).decode(response.data)
+        throw errCode(new Error('Error in fetch protocol response: ' + errmsg), codes.ERR_INVALID_PARAMETERS)
+      }
+      default: {
+        throw errCode(new Error('Unknown response status'), codes.ERR_INVALID_MESSAGE)
+      }
+    }
+  }
+
+  /**
+   * Invoked when a fetch request is received.  Reads the request message off the given stream and
+   * 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) {
+    const { stream } = data
+    const shake = handshake(stream)
+    // @ts-expect-error fromReader returns a Source which has no .next method
+    const request = FetchRequest.decode((await lp.decode.fromReader(shake.reader).next()).value.slice())
+
+    let response: FetchResponse
+    const lookup = this._getLookupFunction(request.identifier)
+    if (lookup != null) {
+      const data = await lookup(request.identifier)
+      if (data != null) {
+        response = { status: FetchResponse.StatusCode.OK, data }
+      } else {
+        response = { status: FetchResponse.StatusCode.NOT_FOUND, data: new Uint8Array(0) }
+      }
+    } else {
+      const errmsg = (new TextEncoder()).encode('No lookup function registered for key: ' + request.identifier)
+      response = { status: FetchResponse.StatusCode.ERROR, data: errmsg }
+    }
+
+    shake.write(lp.encode.single(FetchResponse.encode(response)).slice())
+  }
+
+  /**
+   * Given a key, finds the appropriate function for looking up its corresponding value, based on
+   * the key's prefix.
+   */
+  _getLookupFunction (key: string) {
+    for (const prefix of this.lookupFunctions.keys()) {
+      if (key.startsWith(prefix)) {
+        return this.lookupFunctions.get(prefix)
+      }
+    }
+  }
+
+  /**
+   * Registers a new lookup callback that can map keys to values, for a given set of keys that
+   * share the same prefix
+   */
+  registerLookupFunction (prefix: string, lookup: LookupFunction) {
+    if (this.lookupFunctions.has(prefix)) {
+      throw errCode(new Error("Fetch protocol handler for key prefix '" + prefix + "' already registered"), codes.ERR_KEY_ALREADY_EXISTS)
+    }
+
+    this.lookupFunctions.set(prefix, lookup)
+  }
+
+  /**
+   * Registers a new lookup callback that can map keys to values, for a given set of keys that
+   * share the same prefix.
+   */
+  unregisterLookupFunction (prefix: string, lookup?: LookupFunction) {
+    if (lookup != null) {
+      const existingLookup = this.lookupFunctions.get(prefix)
+
+      if (existingLookup !== lookup) {
+        return
+      }
+    }
+
+    this.lookupFunctions.delete(prefix)
+  }
+}

package/src/fetch/pb/proto.ts

@@ -0,0 +1,65 @@
+/* eslint-disable import/export */
+/* eslint-disable @typescript-eslint/no-namespace */
+
+import { encodeMessage, decodeMessage, message, string, enumeration, bytes } from 'protons-runtime'
+import type { Codec } from 'protons-runtime'
+
+export interface FetchRequest {
+  identifier: string
+}
+
+export namespace FetchRequest {
+  export const codec = (): Codec<FetchRequest> => {
+    return message<FetchRequest>({
+      1: { name: 'identifier', codec: string }
+    })
+  }
+
+  export const encode = (obj: FetchRequest): Uint8Array => {
+    return encodeMessage(obj, FetchRequest.codec())
+  }
+
+  export const decode = (buf: Uint8Array): FetchRequest => {
+    return decodeMessage(buf, FetchRequest.codec())
+  }
+}
+
+export interface FetchResponse {
+  status: FetchResponse.StatusCode
+  data: Uint8Array
+}
+
+export namespace FetchResponse {
+  export enum StatusCode {
+    OK = 'OK',
+    NOT_FOUND = 'NOT_FOUND',
+    ERROR = 'ERROR'
+  }
+
+  enum __StatusCodeValues {
+    OK = 0,
+    NOT_FOUND = 1,
+    ERROR = 2
+  }
+
+  export namespace StatusCode {
+    export const codec = () => {
+      return enumeration<typeof StatusCode>(__StatusCodeValues)
+    }
+  }
+
+  export const codec = (): Codec<FetchResponse> => {
+    return message<FetchResponse>({
+      1: { name: 'status', codec: FetchResponse.StatusCode.codec() },
+      2: { name: 'data', codec: bytes }
+    })
+  }
+
+  export const encode = (obj: FetchResponse): Uint8Array => {
+    return encodeMessage(obj, FetchResponse.codec())
+  }
+
+  export const decode = (buf: Uint8Array): FetchResponse => {
+    return decodeMessage(buf, FetchResponse.codec())
+  }
+}

package/src/get-peer.ts

@@ -0,0 +1,57 @@
+import { peerIdFromString } from '@libp2p/peer-id'
+import { Multiaddr } from '@multiformats/multiaddr'
+import errCode from 'err-code'
+import { codes } from './errors.js'
+import { isPeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerInfo } from '@libp2p/interfaces/peer-info'
+
+function peerIdFromMultiaddr (ma: Multiaddr) {
+  const idStr = ma.getPeerId()
+
+  if (idStr == null) {
+    throw errCode(
+      new Error(`${ma.toString()} does not have a valid peer type`),
+      codes.ERR_INVALID_MULTIADDR
+    )
+  }
+
+  try {
+    return peerIdFromString(idStr)
+  } catch (err: any) {
+    throw errCode(
+      new Error(`${ma.toString()} is not a valid peer type`),
+      codes.ERR_INVALID_MULTIADDR
+    )
+  }
+}
+
+/**
+ * Converts the given `peer` to a `Peer` object.
+ */
+export function getPeer (peer: PeerId | Multiaddr | string): PeerInfo {
+  if (isPeerId(peer)) {
+    return {
+      id: peer,
+      multiaddrs: [],
+      protocols: []
+    }
+  }
+
+  if (typeof peer === 'string') {
+    peer = new Multiaddr(peer)
+  }
+
+  let addr
+
+  if (Multiaddr.isMultiaddr(peer)) {
+    addr = peer
+    peer = peerIdFromMultiaddr(peer)
+  }
+
+  return {
+    id: peer,
+    multiaddrs: addr != null ? [addr] : [],
+    protocols: []
+  }
+}

package/src/identify/consts.ts

@@ -0,0 +1,13 @@
+
+import { version } from '../version.js'
+
+export const PROTOCOL_VERSION = 'ipfs/0.1.0' // deprecated
+export const AGENT_VERSION = `js-libp2p/${version}`
+export const MULTICODEC_IDENTIFY = '/ipfs/id/1.0.0' // deprecated
+export const MULTICODEC_IDENTIFY_PUSH = '/ipfs/id/push/1.0.0' // deprecated
+
+export const IDENTIFY_PROTOCOL_VERSION = '0.1.0'
+export const MULTICODEC_IDENTIFY_PROTOCOL_NAME = 'id'
+export const MULTICODEC_IDENTIFY_PUSH_PROTOCOL_NAME = 'id/push'
+export const MULTICODEC_IDENTIFY_PROTOCOL_VERSION = '1.0.0'
+export const MULTICODEC_IDENTIFY_PUSH_PROTOCOL_VERSION = '1.0.0'