helia-coord 1.2.25 → 1.4.0

package/README.md

@@ -1,3 +1,5 @@
 # helia-coord
 
 This is a fork of [ipfs-coord-esm](https://github.com/Permissionless-Software-Foundation/ipfs-coord-esm), adpted for use with [Helia](https://github.com/ipfs/helia) instead of Kubo.
+
+Read the [dev-docs](./dev-docs) for more information.

package/config/global-config.js

@@ -7,7 +7,11 @@ const config = {
   BCH_COINJOIN_ROOM: 'bch-coinjoin-001',
 
   // Time between retrying private messages to a peer.
-  TIME_BETWEEN_RETRIES: 5000
+  TIME_BETWEEN_RETRIES: 5000,
+
+  // Maximum amount of time in milliseconds to wait for a peer to respond to
+  // an /about query, which is used to measure latency between peers.
+  MAX_LATENCY: 20000
 }
 
 export default config

package/dev-docs/pubsub.md

@@ -0,0 +1,3 @@
+# Pubsub
+
+One of the primary functions of the helia-coord library is 

package/dev-docs/startup.md

@@ -0,0 +1,6 @@
+# Startup
+
+Outline of startup procedure:
+
+- Instantiate the library by passing in a configuration object.
+- 

package/dev-docs/temp.md

@@ -0,0 +1,62 @@
+This markdown is for holding temporary piece of text for editing.
+
+## Use cases
+
+### Peers
+
+Peers are other IPFS nodes that the application wants to keep track of. These are peers that make up the subnet.
+
+- `peerList` - An array of IPFS IDs (strings), identifying each peer this node knows about.
+- `peerData` - An object with root properties that match the peer IPFS ID. Each root property represents a peer and contains the data about that peer.
+
+### Pubsub Channels
+
+[Pubsub Channels](https://blog.ipfs.io/29-js-ipfs-pubsub/) are the way that IPFS nodes form a subnet. The members of the subnet are all subscribed to the same pubsub channel.
+
+### Relays
+
+Some nodes using ipfs-coord can elect to become [Circuit Relays](https://docs.libp2p.io/concepts/circuit-relay/). Circuit Relays are critical for keeping the network censorship resistant. They allow nodes that otherwise would not be able to communicate with one another, do so. They assist in punching through network firewalls that would otherwise block communication. They allow the subnet to route around damage and dynamically adjust as nodes enter and leave the subnet.
+
+ipfs-coord will start by connecting to a small set of pre-configured Relays. As it discovers new peers in the subnetwork that have their `isCircuitRelay` flag set, it will expand its connections to as many Relays as it can find.
+
+- `relayList` - An array of IPFS IDs (strings), identifying each Relay this node knows about.
+- `relayData` - An object with root properties that match the relay IPFS ID. Each root property represents a relay and contains the data about that relay.
+
+### Services
+
+Some nodes are 'service providers' while other nodes are 'service consumers'. These [Decentralized Service Providers (Video)](https://youtu.be/m_33rRXEats) can provide traditional 'back end' web services while leveraging the censorship resistance and automatic networking of this library. Apps consuming these services can use this library can track different service providers, to dynamically load the services it needs to function.
+
+- `serviceList` - An array of IPFS IDs (strings), identifying each Service this node knows about.
+- `serviceData` - An object with root properties that match the Services IPFS ID. Each root property represents a Service and contains the data about that Service.
+
+Properties maintained for each Service:
+
+- jwtFee - If the Service requires the purchase of a JWT token to access it, this is the cost of purchasing one. This is an array of objects, with each object describing different fee options. For example, there may be one fee for paying in BCH. There may be another for paying in SLP tokens.
+- jwtDuration - The duration a JWT token lasts before expiring. A number representing hours.
+- `protocol` - The service protocol that this Service offers.
+- `version` - The protocol version that this Service offers.
+- `description` - A brief description of the Service.
+- `documentation` - An optional link to any API documentation needed to consume the Service.
+
+## Controllers
+
+### Pubsub
+
+New messages arriving for a pubsub channel will trigger an event that will cause this library to process and route the message to the appropriate handler. A few classes of message:
+
+- Announcement - Announcement messages from other peers will be routed to the Peer Entity. If its a new peer, it will be added to the list of known peers.
+
+  - Services - A peer advertising specific services will be passed on to the Services Entity.
+  - Relays - A peer advertising Circuit Relay capability will be passed on to the Relays Entity.
+
+- Private Messages - Each peer has a pubsub channel that is the same name as its IPFS ID. Messages arriving on this channel are expected to be e2e encrypted with the peers public key. Any unencrypted messages are ignored.
+
+### Timers
+
+- Announce Self - This controller announces the presence of the IPFS node by publishing a message to the general coordination pubsub channel. If it's a service provider, it will also announce itself in the service-specific coordination channel.
+
+- Update Peers - This controller reviews the data about each known peer, and prunes away any peers that have not announced themselves for a period of time. It attempts to renew connections to each peer in the list.
+
+- Update Relays - This controller reviews the data about each known Circuit Relay. It attempts to renew the connection to each known Circuit Relay.
+
+- Update Services - This controller reviews the data about each known Service Provider. It prunes any services that it has not been able to connect to over a period of time.

package/dev-docs/theory-of-operation.md

@@ -1,7 +1,26 @@
 # Theory of Operation
 
-This document provides a high-level overview of what the helia-coord library does.
-Helia-coord is middleware that controls a Helia IPFS node. It is used to form an on-the-fly, self-healing mesh network of other IPFS nodes. The nodes communicate over *pubsub channels*, and state is managed by *interval timers*.
+This document provides a high-level overview of the helia-coord library.
+Helia-coord is middleware that controls a Helia IPFS node. It is used to form an on-the-fly, self-healing mesh network of other IPFS nodes. It tracks its connection to other nodes on the network with *entities*. The nodes communicate over *[pubsub channels](https://docs.libp2p.io/concepts/pubsub/overview/)*, and state is managed by *interval timers*.
+
+## Entities
+
+There are three main entities tracked by helia-coord:
+- *thisNode* - represents the IPFS node controlled by helia-coord.
+- *peers* - are other IPFS peers on the network tracked by helia-coord.
+- *relays* - are special *peers* that can establish a webRTC [Circuit Relay](https://docs.libp2p.io/concepts/nat/circuit-relay/) connection between nodes that can not talk to one another directly.
+- *pubsub* channels - are communication channels that nodes subscribe to in order to communicate.
+
+These entities are all stateless, meaning that that the node starts by knowing nothing about itself or the other peers on the network. The entities are created at run-time. They are created and information is added to them as the node discovers more about itself and the other peers on the network over time.
+
+### thisNode
+The *thisNode* entity represents the Helia IPFS node controlled by helia-coord. There is only *one* instance of *thisNode*.
+
+### peers
+A peer entity represents other IPFS nodes on the network that are also running the helia-coord library. These are entities that the *thisNode* entity wants to track and maintain connections to.
+
+### relays
+Relay entities are peers, but not all peers are relays. Relays are a special peers with a public IP address, and run the [v2 Circuit Relay protocol](https://docs.libp2p.io/concepts/nat/circuit-relay/). *peer* entities that are behind firewalls and can not connect to one another directly, can connect through a *relay*.
 
 ## Pubsub Channels
 

package/dev-docs/usage-and-code.md

@@ -0,0 +1,115 @@
+# ipfs-coord Specifications
+
+## Overview
+
+ipfs-coord is a shortening of the word 'coordination'. It is a JavaScript npm library that helps applications using [js-ipfs](https://github.com/ipfs/js-ipfs) coordinate with other peers running related applications.
+
+This document contains a high-level, human-readable specification for the four major architectural areas of the ipfs-coord library:
+
+- Entities
+- Use Cases
+- Controllers (inputs)
+- Adapters (outputs)
+
+This reflects the [Clean Architecture](https://troutsblog.com/blog/clean-architecture) design pattern.
+
+After the ipfs-coord library is instantiated, it will have properties `useCases`, `controllers`, and `adapters` that have methods corresponding to the descriptions in this document. Apps can exercise the features of the ipfs-coord library through this object-oriented structure.
+
+## Configuration
+
+When instantiating the ipfs-coord library, the following configuration inputs can be passed to its constructor via an object with the properties indicated below. Be sure to check out the [examples directory](../examples) for examples on how to instantiate the library with different configurations.
+
+- `ipfs`: (required) An instance of [js-ipfs](https://www.npmjs.com/package/ipfs). IPFS must be instantiated outside of ipfs-coord and passed into it when instantiating the ipfs-coord library.
+- `bchjs`: (required) An instance of [bch-js](https://www.npmjs.com/package/@psf/bch-js). bch-js must be instantiated outside of ipfs-coord and passed into it when instantiating the ipfs-coord library.
+- `type`: (required) A string with the value of 'browser' or 'node.js', to indicate what type of app is instantiating the library. This will determine the types of Circuit Relays the library can connect to.
+- `statusLog`: A function for handling status output strings on the status of ipfs-coord. This defaults to `console.log` if not specified.
+- `privateLog`: A function for handling private messages passed to this node from peer nodes. This defaults to `console.log` if not specified.
+
+## Entities
+
+Entities make up the core business concepts. If these entities change, they fundamentally change the entire app.
+
+### thisNode
+
+`thisNode` is the IPFS node consuming the ipfs-coord library. The thisNode Entity creates a representation the 'self' and maintains the state of the IPFS node, BCH wallet, peers, relays, and pubsub channels that the node is tracking.
+
+## Use Cases
+
+Use cases are verbs or actions that is done _to_ an Entity or _between_ Entities.
+
+### thisNode
+
+The `this-node-use-cases.js` library contains the following Use Cases:
+
+- `createSelf()` - initializes the `thisNode` Entity. It takes the following actions:
+
+  - It retrieves basic information about the IPFS node like the ID and multiaddresses.
+  - It creates a BCH wallet and generates addresses for payments and a public key used for end-to-end encryption (e2ee).
+  - It creates an OrbitDB used to receive private e2ee messages.
+  - It initializes the Schema library for passing standardized messages.
+
+- `addSubnetPeer()` - This is an event handler that is triggered when an 'announcement object' is recieved on the general coordination pubsub channel. That object is passed to `addSubnetPeer()` to be processed. It will analyze the announcement object and add the peer to the array of peers tracked by the thisNode Entity. If the peer is already known, its data will be updated.
+
+- `refreshPeerConnections()` - is periodically called by the Timer Controller. It checks to see if thisNode is still connected to all the subnet peers. It will refresh the connection if they have been disconnected. Circuit Relays are used to connect to other subnet peers, and each known circuit relay will be cycled through until a connection can be established between thisNode and the subnet peer.
+
+### Relays
+
+The `relay-use-cases.js` library controls the interactions between thisNode and the Circuit Relays that it knows about.
+
+- `initializeRelays()` - The ipfs-coord library comes with a pre-programmed list of Circuit Relay nodes. This list is stored in `config/bootstrap-circuit-relays.js`. The `initializeRelays()` method is called once at startup to connect to these relays. This is what 'bootstraps' thisNode to the IPFS sub-network and allows it to find subnetwork peers. After that initial bootstrap connection, thisNode will automatically learn about and connect to other peers and circuit relays.
+
+- `connectToCRs()` - This method is called periodically by the Timer Controller. It checks the connection between thisNode and each Circuit Relay node. If thisNode has lost its connection, the connection is restored.
+
+### Pubsub
+
+The `pubsub-use-cases.js` has a single method:
+
+- `initializePubsub()` is called at startup to connect the node to the general coordination pubsub channel. This is the channel where other apps running the ipfs-coord library announce themselves to other peers in the subnet.
+
+## Controllers
+
+Controllers are inputs to the system. When a controller is activated, it causes the system to react in some way.
+
+### Timers
+
+The controllers listed in this section are activated periodically by a timer. They do routine maintenance.
+
+- `startTimers()` is called at startup. It initializes the other timer controllers.
+
+- `manageCircuitRelays()` calls the `connectToCRs()` Use Case to refresh connections to other circuit relays.
+
+- `manageAnnouncement()` periodically announces the presence of thisNode Entity on the general coordination pubsub channel. It allows other subnet peers to find the node.
+
+- `managePeers()` checks the list of known subnet peers tracked by thisNode Entity. It will restore the connection to each peer if they get disconnected.
+
+## Adapters
+
+Adapters are the 'outputs' of the system. They are the interfaces that this library manipulates in order to maintain the state of the Entities. Adapters ensure that the business logic doesn't need to know any specific information about the outputs.
+
+### bch-adapter.js
+
+[bch-js](https://github.com/Permissionless-Software-Foundation/bch-js) is the Bitcoin Cash (BCH) library used to handle payments and end-to-end encryption in peer communication. When the IPFS node is started, it generates a BCH address to receive payments in BCH, and an SLP address to receive payments in SLP tokens. The same private key used to generate these addresses is used to decrypt incoming pubsub messages, and the public key is passed on to other peers so that they can encrypt messages they want to send thisNode.
+
+### ipfs-adapter.js
+
+This library is designed primarily to control an IPFS node. However, it does not load IPFS directly. It expects the developer to inject an instance of js-ipfs when instantiating this library.
+
+### orbitdb-adapter.js
+
+[OrbitDB](https://orbitdb.org/) is a database that runs on top of IPFS. It's used in this library to prevent 'dropped calls'. As nodes are constantly adjusting their network connections, they can sometimes miss pubsub messages. Other peers in the subnet maintain short-lived logs of the encrypted messages directed at the peers they are connected to. This allows them to pass the message on when the peer reconnects to them, preventing 'dropped calls'. These logs are abandoned after an hour and a new log is created, to prevent them from growing too large.
+
+### encryption-adapter.js
+
+The encryption adapter is responsible for encryption and decryption of pubsub messages. It uses the same Eliptic Curve cryptography used by the Bitcoin protocol. The same private key that is used to generate the BCH address assigned to thisNode is the same private key used to decrypt incoming messages.
+
+Other subnet peers that thisNode tracks will pass on their public key. All messages sent between nodes is encrypted with the receivers public key. Any unencrypted messages are ignored.
+
+### pubsub-adapter.js
+
+The pubsub adapter can publish a message to a pubsub channel, and route incoming messages to an appropriate handler. There are (public) coordination channels that many peers subscribe to, and messages are published unencrypted.
+
+Private messages between peers are _not_ controlled by this library. Those messages are published to OrbitDB and use pubsub messages indirectly, rather than being directly published to a pubsub channel by this library.
+
+### schema.js
+
+The schema library contain formatted JSON objects that are used to generate a standardized messages for communication between peers. The schema.js library is instantiated at startup and appended to the thisNode Entity.

package/examples/create-helia-node.js

@@ -0,0 +1,154 @@
+/*
+  This library creates a Helia IPFS node. This is done prior to attaching
+  helia-coord to the node.
+  This library is called by start-node.js.
+*/
+
+// Global npm libraries
+import { createHelia } from 'helia'
+import fs from 'fs'
+import { FsBlockstore } from 'blockstore-fs'
+import { FsDatastore } from 'datastore-fs'
+import { createLibp2p } from 'libp2p'
+import { tcp } from '@libp2p/tcp'
+import { noise } from '@chainsafe/libp2p-noise'
+import { yamux } from '@chainsafe/libp2p-yamux'
+// import { bootstrap } from '@libp2p/bootstrap'
+import { identifyService } from 'libp2p/identify'
+// import { identify } from '@libp2p/identify'
+import { circuitRelayTransport } from 'libp2p/circuit-relay'
+// import { circuitRelayServer, circuitRelayTransport } from '@libp2p/circuit-relay-v2'
+import { gossipsub } from '@chainsafe/libp2p-gossipsub'
+import { webSockets } from '@libp2p/websockets'
+import { publicIpv4 } from 'public-ip'
+import { multiaddr } from '@multiformats/multiaddr'
+import { webRTC } from '@libp2p/webrtc'
+
+const ROOT_DIR = './'
+const IPFS_DIR = './.ipfsdata/ipfs'
+
+class CreateHeliaNode {
+  constructor () {
+    this.publicIp = publicIpv4
+  }
+
+  // Start an IPFS node.
+  async start () {
+    try {
+      // Ensure the directory structure exists that is needed by the IPFS node to store data.
+      this.ensureBlocksDir()
+
+      // Create an IPFS node
+      const ipfs = await this.createNode()
+      // console.log('ipfs: ', ipfs)
+
+      this.id = ipfs.libp2p.peerId.toString()
+      console.log('IPFS ID: ', this.id)
+
+      // Attempt to guess our ip4 IP address.
+      const ip4 = await this.publicIp()
+      let detectedMultiaddr = `/ip4/${ip4}/tcp/4001/p2p/${this.id}`
+      detectedMultiaddr = multiaddr(detectedMultiaddr)
+
+      // Get the multiaddrs for the node.
+      const multiaddrs = ipfs.libp2p.getMultiaddrs()
+      multiaddrs.push(detectedMultiaddr)
+      console.log('Multiaddrs: ', multiaddrs)
+
+      this.multiaddrs = multiaddrs
+
+      // Signal that this adapter is ready.
+      this.isReady = true
+
+      this.ipfs = ipfs
+
+      return this.ipfs
+    } catch (err) {
+      console.error('Error in start()')
+
+      throw err
+    }
+  }
+
+  // This function creates an IPFS node using Helia.
+  // It returns the node as an object.
+  async createNode () {
+    try {
+      // Create block and data stores.
+      const blockstore = new FsBlockstore(`${IPFS_DIR}/blockstore`)
+      const datastore = new FsDatastore(`${IPFS_DIR}/datastore`)
+
+      // Configure services
+      const services = {
+        identify: identifyService(),
+        pubsub: gossipsub({ allowPublishToZeroPeers: true })
+      }
+
+      // libp2p is the networking layer that underpins Helia
+      const libp2p = await createLibp2p({
+        datastore,
+        addresses: {
+          listen: [
+            '/ip4/127.0.0.1/tcp/0',
+            '/ip4/0.0.0.0/tcp/4001',
+            '/ip4/0.0.0.0/tcp/4003/ws',
+            '/webrtc'
+          ]
+        },
+        transports: [
+          tcp(),
+          webSockets(),
+          circuitRelayTransport({ discoverRelays: 3 }),
+          webRTC()
+        ],
+        connectionEncryption: [
+          noise()
+        ],
+        streamMuxers: [
+          yamux()
+        ],
+        services
+      })
+
+      // create a Helia node
+      const helia = await createHelia({
+        blockstore,
+        datastore,
+        libp2p
+      })
+
+      return helia
+    } catch (err) {
+      console.error('Error creating Helia node: ', err)
+
+      throw err
+    }
+  }
+
+  async stop () {
+    await this.ipfs.stop()
+
+    return true
+  }
+
+  // Ensure that the directories exist to store blocks from the IPFS network.
+  // This function is called at startup, before the IPFS node is started.
+  ensureBlocksDir () {
+    try {
+      !fs.existsSync(`${ROOT_DIR}.ipfsdata`) && fs.mkdirSync(`${ROOT_DIR}.ipfsdata`)
+
+      !fs.existsSync(`${IPFS_DIR}`) && fs.mkdirSync(`${IPFS_DIR}`)
+
+      !fs.existsSync(`${IPFS_DIR}/blockstore`) && fs.mkdirSync(`${IPFS_DIR}/blockstore`)
+
+      !fs.existsSync(`${IPFS_DIR}/datastore`) && fs.mkdirSync(`${IPFS_DIR}/datastore`)
+
+      return true
+    } catch (err) {
+      console.error('Error in ensureBlocksDir(): ', err)
+      throw err
+    }
+  }
+}
+
+export default CreateHeliaNode

package/examples/start-node.js

@@ -0,0 +1,34 @@
+/*
+  This is an example of how to start a Helia IPFS node with node.js and attach
+  the helia-coord library to it.
+*/
+
+// Global npm libraries
+import SlpWallet from 'minimal-slp-wallet'
+
+// Local libraries
+import IpfsCoord from '../index.js'
+import CreateHeliaNode from './create-helia-node.js'
+
+async function start () {
+  // Create an instance of bch-js and IPFS.
+  const wallet = new SlpWallet()
+  await wallet.walletInfoPromise
+
+  const createHeliaNode = new CreateHeliaNode()
+  const ipfs = await createHeliaNode.start()
+
+  // Pass bch-js and IPFS to ipfs-coord when instantiating it.
+  const ipfsCoord = new IpfsCoord({
+    ipfs,
+    wallet,
+    type: 'node.js',
+    // type: 'browser'
+    nodeType: 'external',
+    debugLevel: 2
+  })
+
+  await ipfsCoord.start()
+  console.log('IPFS and the coordination library is ready.')
+}
+start()

package/index.js

@@ -34,6 +34,7 @@ class IpfsCoord {
     // 0 = no debug information.
     // 1 = status logs
     // 2 = verbose errors about peer connections
+    // 3 = everything
     this.debugLevel = parseInt(localConfig.debugLevel)
     if (!this.debugLevel) this.debugLevel = 0
     localConfig.debugLevel = this.debugLevel
@@ -80,15 +81,20 @@ class IpfsCoord {
     await this.adapters.ipfs.start()
 
     // Create an instance of the 'self' which represents this IPFS node, BCH
-    // wallet, and other things that make up this ipfs-coord powered IPFS node.
+    // wallet, and other things that make up this helia-coord powered IPFS node.
     this.thisNode = await this.useCases.thisNode.createSelf({ type: this.type })
     // console.log('thisNode: ', this.thisNode)
 
+    // Pass instance of thisNode to the other use-case libraries.
+    this.useCases.peer.updateThisNode({ thisNode: this.thisNode, peerUseCases: this.useCases.peer })
+    this.useCases.pubsub.updateThisNode(this.thisNode)
+
     // Subscribe to Pubsub Channels
-    await this.useCases.pubsub.initializePubsub(this.thisNode)
+    // await this.useCases.pubsub.initializePubsub(this.thisNode)
+    await this.useCases.pubsub.initializePubsub({ controllers: this.controllers })
 
     // Start timer-based controllers.
-    await this.controllers.timer.startTimers(this.thisNode, this.useCases)
+    await this.controllers.timer.startTimers(this.thisNode)
 
     // Kick-off initial connection to Circuit Relays and Peers.
     // Note: Deliberatly *not* using await here, so that it doesn't block startup
@@ -104,15 +110,11 @@ class IpfsCoord {
   // after this initial function.
   async _initializeConnections () {
     try {
-      // Connect to Circuit Relays
-      await this.useCases.relays.initializeRelays(this.thisNode)
-      console.log('Initial connections to Circuit Relays complete.')
-
       // Load list of Circuit Relays from GitHub Gist.
       await this.useCases.relays.getCRGist(this.thisNode)
       console.log('Finished connecting to Circuit Relays in GitHub Gist.')
 
-      await this.useCases.thisNode.refreshPeerConnections()
+      await this.useCases.peer.refreshPeerConnections()
       console.log('Initial connections to subnet Peers complete.')
 
       return true

package/lib/adapters/ipfs-adapter.js

@@ -157,6 +157,9 @@ class IpfsAdapter {
       connectedPeers = connectedPeers.map(x => x.toString())
       this.log.statusLog(1, 'connectedPeers: ', connectedPeers)
 
+      // const connections = this.ipfs.libp2p.getConnections()
+      // console.log('connections: ', connections)
+
       return connectedPeers
     } catch (err) {
       console.error('Error in ipfs-adapter.js/getPeers(): ', err)

package/lib/adapters/pubsub-adapter/index.js

@@ -4,7 +4,6 @@
 
 // Local libraries
 import Messaging from './messaging.js'
-import AboutAdapter from './about-adapter.js'
 import { BroadcastRouter, PrivateChannelRouter } from './msg-router.js'
 
 // Libraries for working with default uint8Array Buffers that pubsub uses
@@ -42,7 +41,6 @@ class PubsubAdapter {
 
     // Encapsulate dependencies
     this.messaging = new Messaging(localConfig)
-    this.about = new AboutAdapter(localConfig)
 
     this.nodeType = localConfig.nodeType
     if (!this.nodeType) {
@@ -54,10 +52,18 @@ class PubsubAdapter {
     this.handleNewMessage = this.handleNewMessage.bind(this)
     this.checkForDuplicateMsg = this.checkForDuplicateMsg.bind(this)
     this.manageMsgCache = this.manageMsgCache.bind(this)
+    this.injectMetricsHandler = this.injectMetricsHandler.bind(this)
 
     // State
     this.trackedMsgs = [] // Used reject repeated messages
     this.TRACKED_MSG_SIZE = 100
+    this.relayMetricsHandler = () => {} // placeholder
+  }
+
+  // This function is called by the peer use case library. RPC data for an
+  // /about call (used to measure peer metrics) is passed to this handler.
+  injectMetricsHandler (relayMetricsHandler) {
+    this.relayMetricsHandler = relayMetricsHandler
   }
 
   // Subscribe to a pubsub channel. Any data received on that channel is passed
@@ -98,7 +104,7 @@ class PubsubAdapter {
         }
         const privateRouter = new PrivateChannelRouter(pRouterOptions)
 
-        // Subscribe to the pubsbu channel. Route any incoming messages to the
+        // Subscribe to the pubsub channel. Route any incoming messages to the
         // this library.
         this.ipfs.ipfs.libp2p.services.pubsub.subscribe(chanName.toString())
 
@@ -118,6 +124,26 @@ class PubsubAdapter {
     }
   }
 
+  // Subscribe to the general coordination pubsub channel
+  // Dev Note: I probably don't need to pass in the chanName, since I can pull
+  // that from the global config library.
+  async subscribeToCoordChannel (inObj = {}) {
+    try {
+      const { chanName, handler } = inObj
+
+      // Subscribe to the pubsub channel.
+      this.ipfs.ipfs.libp2p.services.pubsub.subscribe(chanName)
+
+      // Route incoming message events to the appropriate handler.
+      this.ipfs.ipfs.libp2p.services.pubsub.addEventListener('message', handler)
+
+      return true
+    } catch (err) {
+      console.error('Error in subscribeToCoordChannel()')
+      throw err
+    }
+  }
+
   // After the messaging.js library does the lower-level message handling and
   // decryption, it passes the message on to this function, which does any
   // additional parsing needed, and
@@ -182,7 +208,8 @@ class PubsubAdapter {
 
         // This event is handled by the about-adapter.js. It measures the
         // latency between peers.
-        this.about.relayMetricsReceived(decryptedStr)
+        // this.about.relayMetricsReceived(decryptedStr)
+        this.relayMetricsHandler(decryptedStr)
 
         return data.result.value
       }
@@ -196,6 +223,7 @@ class PubsubAdapter {
     }
   }
 
+  // CT 1/21/24: This function will be deprecated and moved to pubsub use cases.
   // Attempts to parse data coming in from a pubsub channel. It is assumed that
   // the data is a string in JSON format. If it isn't, parsing will throw an
   // error and the message will be ignored.
@@ -259,6 +287,7 @@ class PubsubAdapter {
     }
   }
 
+  // CT 1/21/24: This function will be deprecated and moved to pubsub use cases.
   // Checks to see if a message has already been processed. This protects against
   // redundent processing.
   checkForDuplicateMsg (msg) {
@@ -282,6 +311,7 @@ class PubsubAdapter {
     return true
   }
 
+  // CT 1/21/24: This function will be deprecated and moved to pubsub use cases.
   // Keep the message queue to a resonable size.
   manageMsgCache () {
     // console.log(`trackedMsgs: `, this.trackedMsgs)

package/lib/controllers/index.js

@@ -5,6 +5,7 @@
 
 // const TimerControllers = require('./timer-controller')
 import TimerControllers from './timer-controller.js'
+import PubsubController from './pubsub-controller.js'
 
 class Controllers {
   constructor (localConfig = {}) {
@@ -15,9 +16,16 @@ class Controllers {
         'Instance of adapters required when instantiating Controllers'
       )
     }
+    this.useCases = localConfig.useCases
+    if (!this.useCases) {
+      throw new Error(
+        'Instance of useCases required when instantiating Controllers'
+      )
+    }
 
     // Encapsulate dependencies
     this.timer = new TimerControllers(localConfig)
+    this.pubsub = new PubsubController(localConfig)
   }
 }