helia-coord 1.1.0

package/lib/adapters/pubsub-adapter/msg-router.js

@@ -0,0 +1,58 @@
+/*
+  This library routes incoming pubsub messages to the appropriate handler.
+*/
+
+// This class routes 'normal' messages, which are broadcast message.
+class BroadcastRouter {
+  constructor (localConfig = {}) {
+    this.handler = localConfig.handler
+    this.thisNode = localConfig.thisNode
+    this.parsePubsubMessage = localConfig.parsePubsubMessage
+
+    this.route = this.route.bind(this)
+  }
+
+  async route (msg) {
+    try {
+      await this.parsePubsubMessage(msg, this.handler, this.thisNode)
+
+      return true
+    } catch (err) {
+      console.error('Error trying to route broadcast pubsub message: ', err)
+      // Do not throw an error. This is a top-level handler.
+
+      return false
+    }
+  }
+}
+
+// This class routes 'private' messages sent on this nodes private, encrypted
+// pubsub channel, which is used for direct communication.
+class PrivateChannelRouter {
+  constructor (localConfig = {}) {
+    this.messaging = localConfig.messaging
+    this.thisNode = localConfig.thisNode
+    this.handleNewMessage = localConfig.handleNewMessage
+
+    this.route = this.route.bind(this)
+  }
+
+  async route (msg) {
+    try {
+      const msgObj = await this.messaging.handleIncomingData(msg, this.thisNode)
+
+      // If msgObj is false, then ignore it. Typically indicates an already
+      // processed message.
+      if (msgObj) { await this.handleNewMessage(msgObj, this.thisNode) }
+
+      return true
+    } catch (err) {
+      console.error('Error trying to route private pubsub message: ', err)
+      // Do not throw an error. This is a top-level handler.
+
+      return false
+    }
+  }
+}
+
+export { BroadcastRouter, PrivateChannelRouter }

package/lib/adapters/pubsub-adapter/resend-msg.js

@@ -0,0 +1,58 @@
+/*
+  This class library is used by the messaging.js library to periodically
+  resend messages until they are acknowledged.
+*/
+
+const RETRY_LIMIT = 3
+
+class ResendMsg {
+  constructor (localConfig = {}) {
+    this.msgObj = localConfig.msgObj
+    this.msgLib = localConfig.msgLib
+
+    // Bind the 'this' object to all subfunctions
+    this.resend = this.resend.bind(this)
+  }
+
+  // Called by an Interval Timer. This function re-publishes a message to a
+  // pubsub channel.
+  async resend () {
+    try {
+      // console.log(`resendMsg() msgObj: ${JSON.stringify(msgObj, null, 2)}`)
+
+      if (!this.msgObj) {
+        console.log('ipfs-coord-esm/lib/adapters/pubsub-adapter/resend-msg.js/resend() given empty message object. Can not resend message. Skipping.')
+        return 0
+      }
+
+      const { retryCnt, intervalHandle, receiver } = this.msgObj
+
+      // Throw an error if the retry count is not an integer.
+      const testRetryCnt = parseInt(retryCnt)
+      if (isNaN(testRetryCnt)) throw new Error('retryCnt must be an integer')
+
+      if (retryCnt < RETRY_LIMIT) {
+        // Increment the retry
+        this.msgObj.retryCnt++
+
+        // Send message
+        await this.msgLib.publishToPubsubChannel(receiver, this.msgObj)
+
+        return 1
+      } else {
+        // Retry count exceeded.
+
+        // Disable the interval handler
+        clearInterval(intervalHandle)
+
+        return 2
+      }
+    } catch (err) {
+      console.error('Error in resendMsg(): ', err)
+      // Do not throw an error. This is a top-level function called by an Interval.
+      return 0
+    }
+  }
+}
+
+export default ResendMsg

package/lib/controllers/index.js

@@ -0,0 +1,24 @@
+/*
+  This is a top-level Controllers library. This library loads all other
+  controller libraries.
+*/
+
+// const TimerControllers = require('./timer-controller')
+import TimerControllers from './timer-controller.js'
+
+class Controllers {
+  constructor (localConfig = {}) {
+    // Dependency Injection
+    this.adapters = localConfig.adapters
+    if (!this.adapters) {
+      throw new Error(
+        'Instance of adapters required when instantiating Controllers'
+      )
+    }
+
+    // Encapsulate dependencies
+    this.timer = new TimerControllers(localConfig)
+  }
+}
+
+export default Controllers

package/lib/controllers/timer-controller.js

@@ -0,0 +1,417 @@
+/*
+  This Controller library is concerned with timer-based functions that are
+  kicked off periodicially. These functions maintain connections and state
+  of the IPFS node.
+*/
+
+// Local libraries
+import Util from '../util/utils.js'
+
+const DEFAULT_COORDINATION_ROOM = 'psf-ipfs-coordination-002'
+
+class TimerControllers {
+  constructor (localConfig = {}) {
+    // Dependency Injection
+    this.adapters = localConfig.adapters
+    if (!this.adapters) {
+      throw new Error(
+        'Instance of adapters required when instantiating Timer Controllers'
+      )
+    }
+    this.statusLog = localConfig.statusLog
+    if (!this.statusLog) {
+      throw new Error(
+        'Handler for status logs required when instantiating Timer Controllers'
+      )
+    }
+
+    // Encapsulate dependencies
+    this.util = new Util()
+    this.sleep = this.util.sleep
+
+    // state
+    this.debugLevel = localConfig.debugLevel
+    this.config = localConfig
+    this.circuitRelayTimerInterval = 60000
+    this.announceTimerInterval = 31000
+    this.peerTimerInterval = 2 * 50000
+    this.relaySearchInterval = 3 * 60000
+    this.checkBlacklistInterval = 30000
+    this.listPubsubChannelsInterval = 32000
+
+    // Bind 'this' object to all subfunctions
+    this.startTimers = this.startTimers.bind(this)
+    this.stopAllTimers = this.stopAllTimers.bind(this)
+    // this.monitorBandwidth = this.monitorBandwidth.bind(this)
+    this.manageCircuitRelays = this.manageCircuitRelays.bind(this)
+    this.manageAnnouncement = this.manageAnnouncement.bind(this)
+    this.managePeers = this.managePeers.bind(this)
+    this.blacklist = this.blacklist.bind(this)
+    this.searchForRelays = this.searchForRelays.bind(this)
+  }
+
+  startTimers (thisNode, useCases) {
+    const _this = this
+
+    // Periodically maintain the connection to Circuit Relays.
+    this.circuitRelayTimerHandle = setInterval(async function () {
+      await _this.manageCircuitRelays(thisNode, useCases)
+    }, this.circuitRelayTimerInterval) // One Minute
+
+    // Periodically announce this nodes existance to the network.
+    this.announceTimerHandle = setInterval(async function () {
+      await _this.manageAnnouncement(thisNode, useCases)
+    }, this.announceTimerInterval)
+
+    // Periodically maintain the connection to other coordination peers.
+    this.peerTimerHandle = setInterval(async function () {
+      await _this.managePeers(thisNode, useCases)
+    }, this.peerTimerInterval)
+
+    // Periodically try to connect to problematic peers that advertise as
+    // potential circuit relays.
+    this.relaySearchHandle = setInterval(async function () {
+      await _this.searchForRelays(thisNode, useCases)
+    }, this.relaySearchInterval)
+
+    // Periodically ensure we are disconnected from blacklisted peers.
+    this.checkBlacklistHandle = setInterval(async function () {
+      await _this.blacklist(thisNode, useCases)
+    }, this.checkBlacklistInterval)
+
+    this.listPubsubChannelsHandle = setInterval(async function () {
+      await _this.listPubsubChannels()
+    }, this.listPubsubChannelsInterval)
+
+    // Return handles to the different timers.
+    return {
+      circuitRelayTimerHandle: this.circuitRelayTimerHandle,
+      announceTimerHandle: this.announceTimerHandle,
+      peerTimerHandle: this.peerTimerHandle,
+      relaySearchHandle: this.relaySearchHandle,
+      checkBlacklistHandle: this.checkBlacklistHandle,
+      listPubsubChannelsHandle: this.listPubsubChannelsHandle
+    }
+  }
+
+  // Used mostly for testing. Ensures all timers are stopped.
+  async stopAllTimers () {
+    clearInterval(this.circuitRelayTimerHandle)
+    clearInterval(this.announceTimerHandle)
+    clearInterval(this.peerTimerHandle)
+    clearInterval(this.relaySearchHandle)
+    clearInterval(this.checkBlacklistHandle)
+    clearInterval(this.listPubsubChannelsHandle)
+  }
+
+  async listPubsubChannels () {
+    const ipfs = this.adapters.ipfs.ipfs
+
+    // const pubsubChans = await ipfs.pubsub.ls()
+    const pubsubChans = ipfs.libp2p.services.pubsub.subscriptions
+    console.log(`subscribed pubsub channels: ${JSON.stringify(pubsubChans, null, 2)}`)
+    this.adapters.log.statusLog(2, `subscribed pubsub channels: ${JSON.stringify(pubsubChans, null, 2)}`)
+
+    return true
+  }
+
+  // Dev Note: This is not curently used, but code is left because it may be
+  // enabled in the future.
+  // Monitor the bandwidth being consumed by IPFS peers.
+  // async monitorBandwidth (thisNode, useCases) {
+  //   try {
+  //     const ipfs = this.adapters.ipfs.ipfs
+
+  //     // const bw = await ipfs.stats.bw()
+  //     // console.log('bw: ', bw)
+  //     for await (const stats of ipfs.stats.bw()) {
+  //     // console.log(stats)
+  //       this.adapters.log.statusLog(2, 'Bandwidth stats: ', stats)
+  //     // this.adapters.log.statusLog(2, `${JSON.stringify(stats, null, 2)}`)
+  //     }
+
+  //     const bitswap = await ipfs.stats.bitswap()
+  //     this.adapters.log.statusLog(2, 'bitswap stats: ', bitswap)
+  //     // this.adapters.log.statusLog(2, `${JSON.stringify(bitswap, null, 2)}`)
+
+  //     return true
+
+  //   } catch (err) {
+  //     console.error('Error in timer-controller.js/monitorBandwidth(): ', err)
+  //     // this.adapters.log.statusLog(
+  //     //   2,
+  //     //   'Error in timer-controller.jsmonitorBandwidth(): ',
+  //     //   err
+  //     // )
+
+  //     // Note: Do not throw an error. This is a top-level function.
+  //     return false
+  //   }
+  // }
+
+  // This function is intended to be called periodically by setInterval().
+  // This function finds circuit relays on the network that can be used
+  // to relay data to other nodes behind firewalls.
+  async manageCircuitRelays (thisNode, useCases) {
+    try {
+      this.adapters.log.statusLog(3, 'Entering manageCircuitRelays() Controller.')
+
+      // Disable the timer while processing is happening.
+      clearInterval(this.circuitRelayTimerHandle)
+
+      // Remove any duplicate entries
+      useCases.relays.removeDuplicates(thisNode)
+
+      // Maintain connections to Relays.
+      await useCases.relays.connectToCRs(thisNode)
+
+      // Update metrics on Relays.
+      await useCases.relays.measureRelays(thisNode)
+
+      const now = new Date()
+      this.adapters.log.statusLog(1,
+        `Renewed connections to all circuit relays at ${now.toLocaleString()}`
+      )
+
+      // Re-enable the timer interval.
+      const _this = this
+      this.circuitRelayTimerHandle = setInterval(async function () {
+        await _this.manageCircuitRelays(thisNode, useCases)
+      }, this.circuitRelayTimerInterval)
+
+      // console.log('Exiting manageCircuitRelays() Controller.')
+
+      return true
+    } catch (err) {
+      console.error(
+        'Error in timer-controller.js/manageCircuitRelays(): ',
+        err
+      )
+      // this.adapters.log.statusLog(
+      //   2,
+      //   'Error in timer-controller.js/manageCircuitRelays(): ',
+      //   err
+      // )
+
+      // Re-enable the timer interval.
+      const _this = this
+      this.circuitRelayTimerHandle = setInterval(async function () {
+        await _this.manageCircuitRelays(thisNode, useCases)
+      }, this.circuitRelayTimerInterval)
+
+      // Note: Do not throw an error. This is a top-level function.
+      return false
+    }
+  }
+
+  // This function is intended to be called periodically by setInterval().
+  // Announce the existance of this node to the network.
+  async manageAnnouncement (thisNode, useCases) {
+    try {
+      // console.log('thisNode: ', thisNode)
+
+      // Disable the timer interval while this function executes.
+      clearInterval(this.announceTimerHandle)
+
+      // Get the information needed for the announcement.
+      const announceObj = {
+        ipfsId: thisNode.ipfsId,
+        ipfsMultiaddrs: thisNode.ipfsMultiaddrs,
+        type: thisNode.type,
+        // orbitdbId: thisNode.orbit.id,
+
+        // TODO: Allow node.js apps to pass a config setting to override this.
+        isCircuitRelay: false
+      }
+
+      // Generate the announcement message.
+      const announceMsgObj = thisNode.schema.announcement(announceObj)
+      // console.log(`announceMsgObj: ${JSON.stringify(announceMsgObj, null, 2)}`)
+
+      const announceMsgStr = JSON.stringify(announceMsgObj)
+
+      // Publish the announcement to the pubsub channel.
+      await this.adapters.pubsub.messaging.publishToPubsubChannel(
+        DEFAULT_COORDINATION_ROOM,
+        announceMsgStr
+      )
+
+      const now = new Date()
+      this.adapters.log.statusLog(
+        1,
+        `status: Announced self on ${DEFAULT_COORDINATION_ROOM} pubsub channel at ${now.toLocaleString()}`
+      )
+
+      // Re-enable the timer interval
+      const _this = this
+      this.announceTimerHandle = setInterval(async function () {
+        await _this.manageAnnouncement(thisNode, useCases)
+      }, this.announceTimerInterval)
+
+      return true
+    } catch (err) {
+      console.error('Error in timer-controller.js/manageAnnouncement(): ', err)
+      // this.adapters.log.statusLog(
+      //   2,
+      //   'Error in timer-controller.js/manageAnnouncement(): ',
+      //   err
+      // )
+
+      // Re-enable the timer interval
+      const _this = this
+      this.announceTimerHandle = setInterval(async function () {
+        await _this.manageAnnouncement(thisNode, useCases)
+      }, this.announceTimerInterval)
+
+      // Note: Do not throw an error. This is a top-level function.
+      return false
+    }
+  }
+
+  // This function is intended to be called periodically by setInterval().
+  // It refreshes the connection to all subnet peers thisNode is trying to track.
+  async managePeers (thisNode, useCases) {
+    let success = false
+
+    try {
+      // Disable the timer while processing is happening.
+      clearInterval(this.peerTimerHandle)
+
+      // this.statusLog('managePeers')
+      await useCases.thisNode.refreshPeerConnections()
+
+      // console.error('Error in timer-controller.js/manageAnnouncement(): ', err)
+      this.adapters.log.statusLog(
+        1,
+        'Renewed connections to all subnet peers.'
+      )
+
+      // Reinstate the timer interval
+      const _this = this
+      this.peerTimerHandle = setInterval(async function () {
+        await _this.managePeers(thisNode, useCases)
+      }, this.peerTimerInterval)
+
+      success = true
+    } catch (err) {
+      console.log('Error in timer-controller.js/managePeers(): ', err)
+      // this.adapters.log.statusLog(
+      //   2,
+      //   'Error in timer-controller.js/managePeers(): ',
+      //   err
+      // )
+
+      // Reinstate the timer interval
+      const _this = this
+      this.peerTimerHandle = setInterval(async function () {
+        await _this.managePeers(thisNode, useCases)
+      }, this.peerTimerInterval)
+
+      // Note: Do not throw an error. This is a top-level function.
+      success = false
+    }
+
+    return success
+  }
+
+  // Actively disconnect from blacklisted peers.
+  // TODO: Rename this to whitelist, as it's not a whitelist function.
+  async blacklist (thisNode, useCases) {
+    let success = false
+
+    try {
+      // Disable the timer while processing is happening.
+      clearInterval(this.checkBlacklistHandle)
+
+      // this.statusLog('managePeers')
+      // await useCases.thisNode.enforceBlacklist()
+      await useCases.thisNode.enforceWhitelist()
+
+      this.adapters.log.statusLog(1, 'Finished enforcing whitelist.')
+
+      // Reinstate the timer interval
+      const _this = this
+      this.checkBlacklistHandle = setInterval(async function () {
+        await _this.blacklist(thisNode, useCases)
+      }, this.checkBlacklistInterval)
+
+      success = true
+    } catch (err) {
+      console.log()
+      // this.adapters.log.statusLog('Error in timer-controller.js/blacklist(): ', err)
+      //   2,
+      //   'Error in timer-controller.js/blacklist(): ',
+      //   err
+      // )
+
+      // Reinstate the timer interval
+      const _this = this
+      this.checkBlacklistHandle = setInterval(async function () {
+        await _this.blacklist(thisNode, useCases)
+      }, this.checkBlacklistInterval)
+
+      // Note: Do not throw an error. This is a top-level function.
+      success = false
+    }
+
+    return success
+  }
+
+  // This method looks for subnet peers that have the isCircuitRelay flag set,
+  // but are not in the list of known relays. These represent potential relays
+  // that thisNode could not connect to, but it might be able to with another
+  // try.
+  async searchForRelays (thisNode, useCases) {
+    try {
+      // console.log('Entering searchForRelays() Controller.')
+
+      // Disable the timer while processing is happening.
+      clearInterval(this.relaySearchHandle)
+
+      // Get all the known relays.
+      const knownRelays = thisNode.relayData.map(x => x.ipfsId)
+      // console.log('knownRelays: ', knownRelays)
+
+      // Get all subnet peers that have their circuit relay flag set.
+      let relayPeers = thisNode.peerData.filter(x => x.data.isCircuitRelay)
+      relayPeers = relayPeers.map(x => x.from)
+      // console.log('relayPeers: ', relayPeers)
+
+      // Diff the two arrays to get relays peers that are not in the relay list.
+      const diffRelayPeers = relayPeers.filter(x => !knownRelays.includes(x))
+      // console.log('diffRelayPeers: ', diffRelayPeers)
+
+      // Try to connect to each potential relay.
+      for (let i = 0; i < diffRelayPeers.length; i++) {
+        const thisPeer = diffRelayPeers[i]
+        await useCases.relays.addRelay(thisPeer, thisNode)
+      }
+
+      // Re-enable the interval timer for this function.
+      const _this = this
+      this.relaySearchHandle = setInterval(async function () {
+        await _this.searchForRelays(thisNode, useCases)
+      }, this.relaySearchInterval)
+
+      return true
+    } catch (err) {
+      console.error('Error in timer-controller.js/searchForRelays(): ', err)
+      // this.adapters.log.statusLog(
+      //   2,
+      //   'Error in timer-controller.js/searchForRelays(): ',
+      //   err
+      // )
+
+      // Re-enable the interval timer for this function.
+      const _this = this
+      this.relaySearchHandle = setInterval(async function () {
+        await _this.searchForRelays(thisNode, useCases)
+      }, this.relaySearchInterval)
+
+      // Note: Do not throw an error. This is a top-level function.
+      return false
+    }
+  }
+}
+
+export default TimerControllers

package/lib/entities/this-node-entity.js

@@ -0,0 +1,102 @@
+/*
+  This is an Entity library for creating a representation the 'self' or
+  the current IPFS node with the adding information of a BCH wallet and
+  any future features added to ipfs-coord.
+
+  There is only one instance of this class library, as there is only one
+  IPFS node that is the 'self'.
+*/
+
+class ThisNodeEntity {
+  // The constructor checks the input data and throws an error if any of the
+  // required data is missing.
+  constructor (localConfig = {}) {
+    this.ipfsId = localConfig.ipfsId
+    if (!this.ipfsId) {
+      throw new Error('ipfsId required when instantiating thisNode Entity')
+    }
+
+    this.ipfsMultiaddrs = localConfig.ipfsMultiaddrs
+    if (!this.ipfsMultiaddrs) {
+      throw new Error(
+        'ipfsMultiaddrs required when instantiating thisNode Entity'
+      )
+    }
+
+    this.bchAddr = localConfig.bchAddr
+    if (!this.bchAddr) {
+      throw new Error('bchAddr required when instantiating thisNode Entity')
+    }
+
+    this.slpAddr = localConfig.slpAddr
+    if (!this.slpAddr) {
+      throw new Error('slpAddr required when instantiating thisNode Entity')
+    }
+
+    this.publicKey = localConfig.publicKey
+    if (!this.publicKey) {
+      throw new Error('publicKey required when instantiating thisNode Entity')
+    }
+
+    this.type = localConfig.type
+    if (!this.type) {
+      throw new Error(
+        "Node type of 'node.js' or 'browser' required when instantiating thisNode Entity"
+      )
+    }
+
+    this.schema = localConfig.schema
+
+    // This Node will keep track of peers, relays, and services.
+    // The 'List' array tracks the IPFS ID for that peer.
+    // The 'Data' array holds instances of the other Entities.
+    this.peerList = []
+    this.peerData = []
+    this.relayData = []
+    this.serviceList = []
+    this.serviceData = []
+
+    // Create a blacklist of nodes that can burden other nodes with excessive bandwidth.
+    this.blacklistPeers = [
+      // '/dns4/node0.preload.ipfs.io/tcp/443/wss/p2p/QmZMxNdpMkewiVZLMRxaNxUeZpDUb34pWjZ1kZvsd16Zic',
+      'QmZMxNdpMkewiVZLMRxaNxUeZpDUb34pWjZ1kZvsd16Zic',
+      // '/dns4/node1.preload.ipfs.io/tcp/443/wss/p2p/Qmbut9Ywz9YEDrz8ySBSgWyJk41Uvm2QJPhwDJzJyGFsD6',
+      'Qmbut9Ywz9YEDrz8ySBSgWyJk41Uvm2QJPhwDJzJyGFsD6',
+      // '/dns4/node2.preload.ipfs.io/tcp/443/wss/p2p/QmV7gnbW5VTcJ3oyM2Xk1rdFBJ3kTkvxc87UFGsun29STS',
+      'QmV7gnbW5VTcJ3oyM2Xk1rdFBJ3kTkvxc87UFGsun29STS',
+      // '/dns4/node3.preload.ipfs.io/tcp/443/wss/p2p/QmY7JB6MQXhxHvq7dBDh4HpbH29v4yE9JRadAVpndvzySN'
+      'QmY7JB6MQXhxHvq7dBDh4HpbH29v4yE9JRadAVpndvzySN',
+      // '/ip4/104.131.131.82/tcp/4001/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ',
+      'QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ',
+      // '/dnsaddr/bootstrap.libp2p.io/p2p/QmNnooDu7bfjPFoTZYxMNLWUQJyrVwtbZg5gBMjTezGAJN',
+      'QmNnooDu7bfjPFoTZYxMNLWUQJyrVwtbZg5gBMjTezGAJN',
+      // '/dnsaddr/bootstrap.libp2p.io/p2p/QmbLHAnMoJPWSCR5Zhtx6BHJX9KiKNN6tpvbUcqanj75Nb',
+      'QmbLHAnMoJPWSCR5Zhtx6BHJX9KiKNN6tpvbUcqanj75Nb',
+      // '/dnsaddr/bootstrap.libp2p.io/p2p/QmZa1sAxajnQjVM8WjWXoMbmPd7NsWhfKsPkErzpm9wGkp',
+      'QmZa1sAxajnQjVM8WjWXoMbmPd7NsWhfKsPkErzpm9wGkp',
+      // '/dnsaddr/bootstrap.libp2p.io/p2p/QmQCU2EcMqAqQPR2i9bChDtGNJchTbq5TbXJJ16u19uLTa',
+      'QmQCU2EcMqAqQPR2i9bChDtGNJchTbq5TbXJJ16u19uLTa',
+      // '/dnsaddr/bootstrap.libp2p.io/p2p/QmcZf59bWwK5XFi76CZX8cbJ4BhTzzA3gU1ZjYZcYW3dwt'
+      'QmcZf59bWwK5XFi76CZX8cbJ4BhTzzA3gU1ZjYZcYW3dwt'
+    ]
+    this.blacklistMultiaddrs = [
+      '/dns4/node0.preload.ipfs.io/tcp/443/wss/p2p/QmZMxNdpMkewiVZLMRxaNxUeZpDUb34pWjZ1kZvsd16Zic',
+      '/dns4/node1.preload.ipfs.io/tcp/443/wss/p2p/Qmbut9Ywz9YEDrz8ySBSgWyJk41Uvm2QJPhwDJzJyGFsD6',
+      '/dns4/node2.preload.ipfs.io/tcp/443/wss/p2p/QmV7gnbW5VTcJ3oyM2Xk1rdFBJ3kTkvxc87UFGsun29STS',
+      '/dns4/node3.preload.ipfs.io/tcp/443/wss/p2p/QmY7JB6MQXhxHvq7dBDh4HpbH29v4yE9JRadAVpndvzySN',
+      '/ip4/104.131.131.82/tcp/4001/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ',
+      '/dnsaddr/bootstrap.libp2p.io/p2p/QmNnooDu7bfjPFoTZYxMNLWUQJyrVwtbZg5gBMjTezGAJN',
+      '/dnsaddr/bootstrap.libp2p.io/p2p/QmbLHAnMoJPWSCR5Zhtx6BHJX9KiKNN6tpvbUcqanj75Nb',
+      '/dnsaddr/bootstrap.libp2p.io/p2p/QmZa1sAxajnQjVM8WjWXoMbmPd7NsWhfKsPkErzpm9wGkp',
+      '/dnsaddr/bootstrap.libp2p.io/p2p/QmQCU2EcMqAqQPR2i9bChDtGNJchTbq5TbXJJ16u19uLTa',
+      '/dnsaddr/bootstrap.libp2p.io/p2p/QmcZf59bWwK5XFi76CZX8cbJ4BhTzzA3gU1ZjYZcYW3dwt',
+      '/dns4/node0.delegate.ipfs.io/tcp/443/https',
+      '/dns4/node1.delegate.ipfs.io/tcp/443/https',
+      '/dns4/node2.delegate.ipfs.io/tcp/443/https',
+      '/dns4/node3.delegate.ipfs.io/tcp/443/https'
+    ]
+  }
+}
+
+// module.exports = ThisNodeEntity
+export default ThisNodeEntity

package/lib/use-cases/index.js

@@ -0,0 +1,36 @@
+/*
+  This is a top-level Use Cases library. This library loads all other
+  use case libraries, and bundles them into a single object.
+*/
+
+// Local libraries
+import ThisNodeUseCases from './this-node-use-cases.js'
+import RelayUseCases from './relay-use-cases.js'
+import PubsubUseCases from './pubsub-use-cases.js'
+import PeerUseCases from './peer-use-cases.js'
+
+class UseCases {
+  constructor (localConfig = {}) {
+    this.adapters = localConfig.adapters
+    if (!this.adapters) {
+      throw new Error(
+        'Must inject instance of adapters when instantiating Use Cases library.'
+      )
+    }
+
+    // Encapsulate dependencies
+    this.thisNode = new ThisNodeUseCases(localConfig)
+
+    // Other use-cases depend on the thisNode use case.
+    localConfig.thisNodeUseCases = this.thisNode
+
+    this.relays = new RelayUseCases(localConfig)
+    this.pubsub = new PubsubUseCases(localConfig)
+    this.peer = new PeerUseCases(localConfig)
+
+    // Pass the instances of the other use cases to the ThisNode Use Cases.
+    this.thisNode.updateUseCases(this)
+  }
+}
+
+export default UseCases