@libp2p/daemon-client 0.0.0

package/src/index.ts

@@ -0,0 +1,263 @@
+import errcode from 'err-code'
+import { TCP } from '@libp2p/tcp'
+import { IRequest, Request, Response } from '@libp2p/daemon-protocol'
+import { StreamHandler } from './stream-handler.js'
+import { Multiaddr } from '@multiformats/multiaddr'
+import { DHT } from './dht.js'
+import { Pubsub } from './pubsub.js'
+import { isPeerId, PeerId } from '@libp2p/interfaces/peer-id'
+import { passThroughUpgrader } from './util/index.js'
+import type { ConnectionHandler, Listener } from '@libp2p/interfaces/transport'
+import { peerIdFromBytes } from '@libp2p/peer-id'
+import type { Duplex } from 'it-stream-types'
+
+class Client implements DaemonClient {
+  private multiaddr: Multiaddr
+  public dht: DHT
+  public pubsub: Pubsub
+  private tcp: TCP
+  private listener?: Listener
+
+  constructor (addr: Multiaddr) {
+    this.multiaddr = addr
+    this.tcp = new TCP()
+
+    this.dht = new DHT(this)
+    this.pubsub = new Pubsub(this)
+  }
+
+  /**
+   * Connects to a daemon at the unix socket path the daemon
+   * was created with
+   *
+   * @async
+   * @returns {MultiaddrConnection}
+   */
+  connectDaemon () {
+    return this.tcp.dial(this.multiaddr, {
+      upgrader: passThroughUpgrader
+    })
+  }
+
+  /**
+   * Starts a server listening at `socketPath`. New connections
+   * will be sent to the `connectionHandler`.
+   *
+   * @param {Multiaddr} addr
+   * @param {function(Stream)} connectionHandler
+   * @returns {Promise}
+   */
+  async start (addr: Multiaddr, connectionHandler: ConnectionHandler) {
+    if (this.listener) {
+      await this.close()
+    }
+
+    this.listener = this.tcp.createListener({
+      handler: maConn => connectionHandler(maConn),
+      upgrader: passThroughUpgrader
+    })
+
+    await this.listener.listen(addr)
+  }
+
+  /**
+   * Sends the request to the daemon and returns a stream. This
+   * should only be used when sending daemon requests.
+   */
+  async send (request: IRequest) {
+    const maConn = await this.connectDaemon()
+
+    const streamHandler = new StreamHandler({ stream: maConn })
+    streamHandler.write(Request.encode(request).finish())
+    return streamHandler
+  }
+
+  /**
+   * Closes the socket
+   */
+  async close () {
+    this.listener && await this.listener.close()
+    this.listener = undefined
+  }
+
+  /**
+   * Connect requests a connection to a known peer on a given set of addresses
+   *
+   * @param {PeerId} peerId
+   * @param {Array.<multiaddr>} addrs
+   */
+  async connect (peerId: PeerId, addrs: Multiaddr[]) {
+    if (!isPeerId(peerId)) {
+      throw errcode(new Error('invalid peer id received'), 'ERR_INVALID_PEER_ID')
+    }
+
+    if (!Array.isArray(addrs)) {
+      throw errcode(new Error('addrs received are not in an array'), 'ERR_INVALID_ADDRS_TYPE')
+    }
+
+    addrs.forEach((addr) => {
+      if (!Multiaddr.isMultiaddr(addr)) {
+        throw errcode(new Error('received an address that is not a multiaddr'), 'ERR_NO_MULTIADDR_RECEIVED')
+      }
+    })
+
+    const sh = await this.send({
+      type: Request.Type.CONNECT,
+      connect: {
+        peer: peerId.toBytes(),
+        addrs: addrs.map((a) => a.bytes)
+      }
+    })
+
+    const message = await sh.read()
+    if (!message) {
+      throw errcode(new Error('unspecified'), 'ERR_CONNECT_FAILED')
+    }
+
+    const response = Response.decode(message)
+    if (response.type !== Response.Type.OK) {
+      const errResponse = response.error ??  { msg: 'unspecified'}
+      throw errcode(new Error(errResponse.msg ?? 'unspecified'), 'ERR_CONNECT_FAILED')
+    }
+
+    await sh.close()
+  }
+
+  /**
+   * @typedef {Object} IdentifyResponse
+   * @property {PeerId} peerId
+   * @property {Array.<multiaddr>} addrs
+   */
+
+  /**
+   * Identify queries the daemon for its peer ID and listen addresses.
+   */
+  async identify (): Promise<IdentifyResult> {
+    const sh = await this.send({
+      type: Request.Type.IDENTIFY
+    })
+
+    const message = await sh.read()
+    const response = Response.decode(message)
+
+    if (response.type !== Response.Type.OK) {
+      throw errcode(new Error(response.error?.msg ?? 'Identify failed'), 'ERR_IDENTIFY_FAILED')
+    }
+
+    if (response.identify == null || response.identify.addrs == null) {
+      throw errcode(new Error('Invalid response'), 'ERR_IDENTIFY_FAILED')
+    }
+
+    const peerId = peerIdFromBytes(response.identify?.id)
+    const addrs = response.identify.addrs.map((a) => new Multiaddr(a))
+
+    await sh.close()
+
+    return ({ peerId, addrs })
+  }
+
+  /**
+   * Get a list of IDs of peers the node is connected to
+   */
+  async listPeers (): Promise<PeerId[]> {
+    const sh = await this.send({
+      type: Request.Type.LIST_PEERS
+    })
+
+    const message = await sh.read()
+    const response = Response.decode(message)
+
+    if (response.type !== Response.Type.OK) {
+      throw errcode(new Error(response.error?.msg ?? 'List peers failed'), 'ERR_LIST_PEERS_FAILED')
+    }
+
+    await sh.close()
+
+    return response.peers.map((peer) => peerIdFromBytes(peer.id))
+  }
+
+  /**
+   * Initiate an outbound stream to a peer on one of a set of protocols.
+   */
+  async openStream (peerId: PeerId, protocol: string): Promise<Duplex<Uint8Array>> {
+    if (!isPeerId(peerId)) {
+      throw errcode(new Error('invalid peer id received'), 'ERR_INVALID_PEER_ID')
+    }
+
+    if (typeof protocol !== 'string') {
+      throw errcode(new Error('invalid protocol received'), 'ERR_INVALID_PROTOCOL')
+    }
+
+    const sh = await this.send({
+      type: Request.Type.STREAM_OPEN,
+      streamOpen: {
+        peer: peerId.toBytes(),
+        proto: [protocol]
+      }
+    })
+
+    const message = await sh.read()
+    const response = Response.decode(message)
+
+    if (response.type !== Response.Type.OK) {
+      await sh.close()
+      throw errcode(new Error(response.error?.msg ?? 'Open stream failed'), 'ERR_OPEN_STREAM_FAILED')
+    }
+
+    return sh.rest()
+  }
+
+  /**
+   * Register a handler for inbound streams on a given protocol
+   */
+  async registerStreamHandler (addr: Multiaddr, protocol: string) {
+    if (!Multiaddr.isMultiaddr(addr)) {
+      throw errcode(new Error('invalid multiaddr received'), 'ERR_INVALID_MULTIADDR')
+    }
+
+    if (typeof protocol !== 'string') {
+      throw errcode(new Error('invalid protocol received'), 'ERR_INVALID_PROTOCOL')
+    }
+
+    const sh = await this.send({
+      type: Request.Type.STREAM_HANDLER,
+      streamOpen: null,
+      streamHandler: {
+        addr: addr.bytes,
+        proto: [protocol]
+      }
+    })
+
+    const message = await sh.read()
+    const response = Response.decode(message)
+
+    await sh.close()
+
+    if (response.type !== Response.Type.OK) {
+      throw errcode(new Error(response.error?.msg ?? 'Register stream handler failed'), 'ERR_REGISTER_STREAM_HANDLER_FAILED')
+    }
+  }
+}
+
+export interface IdentifyResult {
+  peerId: PeerId
+  addrs: Multiaddr[]
+}
+
+export interface DHTClient {
+  put: (key: Uint8Array, value: Uint8Array) => Promise<void>
+  get: (key: Uint8Array) => Promise<Uint8Array>
+}
+
+export interface DaemonClient {
+  identify: () => Promise<IdentifyResult>
+  listPeers: () => Promise<PeerId[]>
+  connect: (peerId: PeerId, addrs: Multiaddr[]) => Promise<void>
+  dht: DHTClient
+
+  send: (request: IRequest) => Promise<StreamHandler>
+}
+
+export function createClient (multiaddr: Multiaddr): DaemonClient {
+  return new Client(multiaddr)
+}

package/src/pubsub.ts

@@ -0,0 +1,106 @@
+import errcode from 'err-code'
+import {
+  Request,
+  Response,
+  PSRequest,
+  PSMessage
+} from '@libp2p/daemon-protocol'
+import type { DaemonClient } from './index.js'
+
+export class Pubsub {
+  private client: DaemonClient
+
+  constructor (client: DaemonClient) {
+    this.client = client
+  }
+
+  /**
+   * Get a list of topics the node is subscribed to.
+   *
+   * @returns {Array<string>} topics
+   */
+  async getTopics (): Promise<string[]> {
+    const sh = await this.client.send({
+      type: Request.Type.PUBSUB,
+      pubsub: {
+        type: PSRequest.Type.GET_TOPICS
+      }
+    })
+
+    const message = await sh.read()
+    const response = Response.decode(message)
+
+    await sh.close()
+
+    if (response.type !== Response.Type.OK) {
+      throw errcode(new Error(response.error?.msg ?? 'Pubsub get topics failed'), 'ERR_PUBSUB_GET_TOPICS_FAILED')
+    }
+
+    if (response.pubsub == null || response.pubsub.topics == null) {
+      throw errcode(new Error('Invalid response'), 'ERR_PUBSUB_GET_TOPICS_FAILED')
+    }
+
+    return response.pubsub.topics
+  }
+
+  /**
+   * Publish data under a topic
+   */
+  async publish (topic: string, data: Uint8Array) {
+    if (typeof topic !== 'string') {
+      throw errcode(new Error('invalid topic received'), 'ERR_INVALID_TOPIC')
+    }
+
+    if (!(data instanceof Uint8Array)) {
+      throw errcode(new Error('data received is not a Uint8Array'), 'ERR_INVALID_DATA')
+    }
+
+    const sh = await this.client.send({
+      type: Request.Type.PUBSUB,
+      pubsub: {
+        type: PSRequest.Type.PUBLISH,
+        topic,
+        data
+      }
+    })
+
+    const message = await sh.read()
+    const response = Response.decode(message)
+
+    await sh.close()
+
+    if (response.type !== Response.Type.OK) {
+      throw errcode(new Error(response.error?.msg ?? 'Pubsub publish failed'), 'ERR_PUBSUB_PUBLISH_FAILED')
+    }
+  }
+
+  /**
+   * Request to subscribe a certain topic
+   */
+  async * subscribe (topic: string) {
+    if (typeof topic !== 'string') {
+      throw errcode(new Error('invalid topic received'), 'ERR_INVALID_TOPIC')
+    }
+
+    const sh = await this.client.send({
+      type: Request.Type.PUBSUB,
+      pubsub: {
+        type: PSRequest.Type.SUBSCRIBE,
+        topic
+      }
+    })
+
+    let message = await sh.read()
+    let response = Response.decode(message)
+
+    if (response.type !== Response.Type.OK) {
+      throw errcode(new Error(response.error?.msg ?? 'Pubsub publish failed'), 'ERR_PUBSUB_PUBLISH_FAILED')
+    }
+
+    // stream messages
+    while (true) {
+      message = await sh.read()
+      yield PSMessage.decode(message)
+    }
+  }
+}

package/src/stream-handler.ts

@@ -0,0 +1,65 @@
+import * as lp from 'it-length-prefixed'
+import { handshake } from 'it-handshake'
+import { logger } from '@libp2p/logger'
+import type { Duplex, Source } from 'it-stream-types'
+import type { Handshake } from 'it-handshake'
+
+const log = logger('libp2p:daemon-client:stream-handler')
+
+export interface StreamHandlerOptions {
+  stream: Duplex<Uint8Array>
+  maxLength?: number
+}
+
+export class StreamHandler {
+  private stream: Duplex<Uint8Array>
+  private shake: Handshake
+  private decoder: Source<Uint8Array>
+  /**
+   * Create a stream handler for connection
+   */
+  constructor (opts: StreamHandlerOptions) {
+    const { stream, maxLength } = opts
+
+    this.stream = stream
+    this.shake = handshake(this.stream)
+    this.decoder = lp.decode.fromReader(this.shake.reader, { maxDataLength: maxLength ?? 4096 })
+  }
+
+  /**
+   * Read and decode message
+   */
+  async read () {
+    // @ts-expect-error decoder is really a generator
+    const msg = await this.decoder.next()
+    if (msg.value) {
+      return msg.value.slice()
+    }
+    log('read received no value, closing stream')
+    // End the stream, we didn't get data
+    this.close()
+  }
+
+  write (msg: Uint8Array) {
+    log('write message')
+    this.shake.write(
+      lp.encode.single(msg).slice()
+    )
+  }
+
+  /**
+   * Return the handshake rest stream and invalidate handler
+   */
+  rest () {
+    this.shake.rest()
+    return this.shake.stream
+  }
+
+  /**
+   * Close the stream
+   */
+  close () {
+    log('closing the stream')
+    this.rest().sink([])
+  }
+}

package/src/util/index.ts

@@ -0,0 +1,27 @@
+import type { Upgrader } from '@libp2p/interfaces/transport'
+import type { Multiaddr } from '@multiformats/multiaddr'
+import { resolve } from 'path'
+
+export const passThroughUpgrader: Upgrader = {
+  // @ts-expect-error
+  upgradeInbound: maConn => maConn,
+  // @ts-expect-error
+  upgradeOutbound: maConn => maConn
+}
+
+/**
+ * Converts the multiaddr to a nodejs NET compliant option
+ * for .connect or .listen
+ *
+ * @param {Multiaddr} addr
+ * @returns {string|object} A nodejs NET compliant option
+ */
+export function multiaddrToNetConfig (addr: Multiaddr) {
+  const listenPath = addr.getPath()
+  // unix socket listening
+  if (listenPath) {
+    return resolve(listenPath)
+  }
+  // tcp listening
+  return addr.nodeAddress()
+}