helia-coord 1.7.2 → 1.9.0

package/README.md

@@ -3,3 +3,7 @@
 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.
+
+## Node Version
+
+Use node.js v22

package/lib/adapters/encryption-adapter.js

@@ -72,6 +72,9 @@ class EncryptionAdapter {
       if (!peer || !peer.data) {
         throw new Error('Peer public key is not available yet.')
       }
+      if (!msg || typeof msg !== 'string') {
+        throw new Error('Message is required.')
+      }
 
       const pubKey = peer.data.encryptPubKey
       // console.log('msg to encrypt: ', msg)

package/lib/adapters/gist.js

@@ -62,7 +62,7 @@ class Gist {
 
       // Retrieve the gist from github.com.
       const result = await this.axios.get(gistUrl)
-      console.log('result.data: ', result.data)
+      // console.log('result.data: ', result.data)
 
       // Get the current content of the gist.
       const content = result.data

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

@@ -129,7 +129,7 @@ class Messaging {
       if (!decryptedPayload) {
         return false
       }
-      this.log.statusLog(2, 'decrypted payload:', decryptedPayload)
+      this.log.statusLog(3, 'decrypted payload:', decryptedPayload)
 
       // Filter ACK messages from other messages
       if (decryptedPayload.includes('"apiName":"ACK"')) {
@@ -237,10 +237,9 @@ class Messaging {
       }
 
       const peerData = thisNode.peerData.filter(x => x.from === receiver)
-
       // 3/24/24 CT - Debugging issue with passing data between ipfs-bch-wallet
       // -service and -consumer.
-      if (!peerData || !peerData[0].data) {
+      if (!peerData || !peerData[0] || !peerData[0].data) {
         console.log(`peerData[0]: ${JSON.stringify(peerData[0])}`)
         throw new Error('Required encryption information for peer is not available.')
       }
@@ -275,7 +274,7 @@ class Messaging {
 
       return outMsgObj
     } catch (err) {
-      console.error('Error in generateAckMsg()')
+      console.error('Error in generateAckMsg()', err)
       throw err
     }
   }

package/lib/use-cases/peer-use-cases.js

@@ -240,7 +240,6 @@ class PeerUseCases {
         if (!thisPeerData) return false
 
         const dataIndex = this.thisNode.peerData.indexOf(thisPeerData)
-        // console.log(`dataIndex: ${dataIndex}`)
 
         // If the new announceObj is older than the last announceObj, then
         // ignore it.
@@ -386,24 +385,19 @@ class PeerUseCases {
           // the multiaddrs in the announcement object.
           const filteredMultiaddrs = this.utils.filterMultiaddrs(peerData.data.ipfsMultiaddrs)
           this.adapters.log.statusLog(1, 'filteredMultiaddrs: ', filteredMultiaddrs)
-
           for (let j = 0; j < filteredMultiaddrs.length; j++) {
             const multiaddr = filteredMultiaddrs[j]
             this.adapters.log.statusLog(1,
               `Trying a direct connection to peer ${thisPeer} with this multiaddr: ${multiaddr}.`
             )
-
             // Attempt to connect to the node through a circuit relay.
             connected = await this.adapters.ipfs.connectToPeer({ multiaddr })
-            // console.log('direct connection connected: ', connected)
-
             // If the connection was successful, break out of the relay loop.
             // Otherwise try to connect through the next relay.
             if (connected.success) {
               this.adapters.log.statusLog(1,
                 `Successfully connected to peer ${thisPeer} through direct connection: ${multiaddr}.`
               )
-
               // Add the connection multiaddr for this peer to the thisNode object.
               this.updatePeerConnectionInfo({ thisPeer })
 
@@ -422,7 +416,6 @@ class PeerUseCases {
             }
           }
         }
-
         if (connected.success) {
           continue
         }
@@ -443,7 +436,6 @@ class PeerUseCases {
           for (let j = 0; j < filteredMultiaddrs.length; j++) {
             const multiaddr = filteredMultiaddrs[j]
             this.adapters.log.statusLog(1, `Trying to connect to peer ${thisPeer} through webRTC multiaddr: ${multiaddr}.`)
-
             connected = await this.adapters.ipfs.connectToPeer({ multiaddr })
 
             // If the connection was successful, break out of the relay loop.
@@ -545,7 +537,7 @@ class PeerUseCases {
 
       return true
     } catch (err) {
-      console.error('Error in refreshPeerConnections()')
+      console.error('Error in refreshPeerConnections()', err)
       throw err
     }
   }
@@ -694,20 +686,18 @@ class PeerUseCases {
 
       // Get multiaddrs that can be used to connect to this node.
       const addrs = this.adapters.ipfs.ipfs.libp2p.getMultiaddrs()
-
       const webRtcAddrs = addrs.filter(x => WebRTC.matches(x))
-      // console.log('webRTC addrs: ', webRtcAddrs)
 
       // If there are any webRTC multiaddrs, add them to the announcement object.
       if (webRtcAddrs.length) {
         // Remove any previous webRTC multiaddrs from the announcement object.
         const existingMultiaddrs = thisNode.ipfsMultiaddrs
         const noRtcAddrs = existingMultiaddrs.filter(x => !x.includes('/p2p-circuit/webrtc'))
-
         // Add the new webRTC multiaddrs to the announcement object.
         webRtcAddrs.forEach(x => {
           noRtcAddrs.push(x.toString())
         })
+        console.log('noRtcAddrs: ', noRtcAddrs)
 
         // Add the new webRTC multiaddrs to the announcement object.
         thisNode.ipfsMultiaddrs = noRtcAddrs

package/lib/use-cases/relay-use-cases.js

@@ -145,7 +145,7 @@ class RelayUseCases {
       // Loop through each relay.
       for (let i = 0; i < knownRelays.length; i++) {
         const thisRelay = knownRelays[i]
-        // console.log('thisRelay: ', thisRelay)
+        console.log('thisRelay: ', thisRelay)
 
         // Get connected peers
         const connectedPeers = await this.adapters.ipfs.getPeers()
@@ -153,7 +153,7 @@ class RelayUseCases {
 
         // Check if target circuit-relay is currently conected to the node.
         const connectedPeer = connectedPeers.filter(peerId => thisRelay.ipfsId.includes(peerId))
-        // console.log('connectedPeer: ', connectedPeer)
+        console.log('connectedPeer: ', connectedPeer)
 
         // Get the peer data corresponding to this relay
         // let peerData = thisNode.peerData.filter(x => x.from.includes(thisRelay.ipfsId))
@@ -192,19 +192,22 @@ class RelayUseCases {
             thisNode.peerData[peerIndex].data.connectionAddr = remoteConnection[0].remoteAddr.toString()
           }
 
-          // console.log(`Multiaddr changed to ${thisRelay.multiaddr}`)
+          console.log(`Multiaddr changed to ${thisRelay.multiaddr}`)
 
           // Debugging: log situations when the relay is connected through
           // another circuit relay.
           if (thisRelay.multiaddr.includes('/p2p-circuit')) {
             for (const connection of libp2p.getConnections()) {
-              console.log('DEBUG: connection.remoteAddr: ', connection.remoteAddr.toString())
               // Logs the PeerId string and the observed remote multiaddr of each Connection
+              this.adapters.log.statusLog(
+                2,
+                `DEBUG: connection.remoteAddr: ${connection.remoteAddr.toString()}`
+              )
             }
           }
         } else {
           // Not connected. Connect to the relay.
-
+          console.log('Handling zero connected peers')
           // console.log('peerData: ', peerData)
 
           // If this node is not connected, try to connect again.
@@ -213,10 +216,12 @@ class RelayUseCases {
             { multiaddr: thisRelay.multiaddr }
           )
           thisRelay.connected = connStatus.success
-          // console.log(`thisRelay.connected: ${thisRelay.connected}`)
+          console.log(`thisRelay.connected: ${thisRelay.connected}`)
 
           // Debugging: Trying to figure out the best way to select the multiaddr
+          console.log('relay multiaddr: ', thisRelay.multiaddr)
           if (thisRelay.connected && !thisRelay.multiaddr.includes('/tcp/')) {
+            // 2/25/25 CT: Have not seen this code path executed in a long time.
             console.log('DEBUG: thisRelay.multiaddr: ', thisRelay.multiaddr)
 
             const libp2p = this.adapters.ipfs.ipfs.libp2p
@@ -475,11 +480,8 @@ class RelayUseCases {
 
         // Get the peer data.
         let peerData = thisNode.peerData.filter(x => {
-          if (!x.data) {
-            console.log('broken peer data: ', x)
-          }
-          // console.log(`x.data.ipfsId: ${x.data.ipfsId}`)
-          // console.log(`thisRelay.ipfsId: ${thisRelay.ipfsId}`)
+          // Skip entries with null or missing data
+          if (!x.data) return false
           return x.data.ipfsId === thisRelay.ipfsId
         })
         peerData = peerData[0]
@@ -522,6 +524,8 @@ class RelayUseCases {
         // Save the new metric value.
         thisRelay.metrics.aboutLatency.push(diffTime)
       }
+
+      return true
     } catch (err) {
       console.error('Error in measureRelays(): ', err)
       throw err

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "helia-coord",
-  "version": "1.7.2",
+  "version": "1.9.0",
   "description": "A JS library for helping IPFS peers coordinate, find a common interest, and stay connected around that interest.",
   "main": "./index.js",
   "type": "module",
@@ -21,16 +21,16 @@
   "homepage": "https://github.com/Permissionless-Software-Foundation/helia-coord#readme",
   "devDependencies": {
     "@chainsafe/libp2p-gossipsub": "14.1.0",
-    "@chainsafe/libp2p-noise": "16.0.1",
-    "@chainsafe/libp2p-yamux": "7.0.1",
+    "@chainsafe/libp2p-noise": "17.0.0",
+    "@chainsafe/libp2p-yamux": "8.0.1",
     "@istanbuljs/esm-loader-hook": "0.2.0",
     "@libp2p/circuit-relay-v2": "3.2.2",
     "@libp2p/identify": "3.0.22",
     "@libp2p/ping": "2.0.22",
-    "@libp2p/tcp": "10.1.2",
+    "@libp2p/tcp": "11.0.10",
     "@libp2p/webrtc": "5.2.2",
-    "@libp2p/websockets": "9.2.2",
-    "@multiformats/multiaddr": "12.3.5",
+    "@libp2p/websockets": "10.1.3",
+    "@multiformats/multiaddr": "13.0.1",
     "@multiformats/multiaddr-matcher": "1.6.0",
     "blockstore-fs": "2.0.2",
     "chai": "4.3.6",
@@ -39,7 +39,7 @@
     "delay": "6.0.0",
     "helia": "5.2.1",
     "lodash.clonedeep": "4.5.0",
-    "minimal-slp-wallet": "5.12.0",
+    "minimal-slp-wallet": "7.1.4",
     "mocha": "10.0.0",
     "nyc": "15.1.0",
     "public-ip": "6.0.1",
@@ -52,7 +52,7 @@
     "uuid": "9.0.0"
   },
   "peerDependencies": {
-    "libp2p": ">=2.6.0"
+    "libp2p": ">=3.1.3"
   },
   "exports": {
     ".": {

package/test/unit/adapters/encryption-adapter-unit.js

@@ -126,6 +126,56 @@ describe('#Adapters - Encryption', () => {
         assert.include(err.message, 'pubkey must be a hex string')
       }
     })
+    it('should throw an error is peer is not provided', async () => {
+      try {
+        await uut.encryptMsg()
+        // console.log('result: ', result)
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'Peer public key is not available yet.')
+      }
+    })
+    it('should throw an error is msg is not provided', async () => {
+      try {
+        const peer = {
+          data: {
+            encryptionKey: 'abc123'
+          }
+        }
+
+        await uut.encryptMsg(peer)
+        // console.log('result: ', result)
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'Message is required.')
+      }
+    })
+    it('should throw an error is peer data is not provided', async () => {
+      try {
+        const peer = {
+        }
+
+        await uut.encryptMsg(peer, 'testMsg')
+        // console.log('result: ', result)
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'Peer public key is not available yet.')
+      }
+    })
+
+    it('should throw and error if peer public key is not available', async () => {
+      try {
+        const peer = {}
+        await uut.encryptMsg(peer, 'testMsg')
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'Peer public key is not available yet.')
+      }
+    })
 
     it('should encrypt a string', async () => {
       // Mock dependencies

package/test/unit/adapters/gist.unit.adapters.js

@@ -55,4 +55,40 @@ describe('#Adapter-Gist', () => {
       }
     })
   })
+
+  describe('#getCRList2', () => {
+    it('should get data from GitHub', async () => {
+      // Mock network dependencies
+      sandbox.stub(uut.axios, 'get').resolves({
+        data: {
+          browser: [],
+          node: [],
+          recommendedPeers: []
+        }
+      })
+
+      const result = await uut.getCRList2()
+      // console.log('result: ', result)
+
+      assert.property(result, 'browser')
+      assert.property(result, 'node')
+      assert.property(result, 'recommendedPeers')
+      assert.isArray(result.browser)
+      assert.isArray(result.node)
+      assert.isArray(result.recommendedPeers)
+    })
+
+    it('should catch and throw errors', async () => {
+      try {
+        // Force desired code path
+        sandbox.stub(uut.axios, 'get').rejects(new Error('test error'))
+
+        await uut.getCRList2()
+
+        assert.fail('Unexpected result')
+      } catch (err) {
+        assert.include(err.message, 'test error')
+      }
+    })
+  })
 })

package/test/unit/adapters/pubsub/messaging-adapter-unit.js

@@ -14,13 +14,14 @@ import ipfsLib from '../../../mocks/ipfs-mock.js'
 import IPFSAdapter from '../../../../lib/adapters/ipfs-adapter.js'
 import EncryptionAdapter from '../../../../lib/adapters/encryption-adapter.js'
 import BchAdapter from '../../../../lib/adapters/bch-adapter.js'
-import thisNode from '../../../mocks/thisnode-mocks.js'
+import thisNodeMock from '../../../mocks/thisnode-mocks.js'
 import ResendMsg from '../../../../lib/adapters/pubsub-adapter/resend-msg.js'
 
 describe('#messaging-adapter', () => {
   let sandbox
   let uut
   let ipfs, ipfsAdapter
+  let thisNode
 
   const log = {
     statusLog: () => {}
@@ -34,6 +35,8 @@ describe('#messaging-adapter', () => {
     ipfs = cloneDeep(ipfsLib)
     ipfsAdapter = new IPFSAdapter({ ipfs, log })
 
+    thisNode = cloneDeep(thisNodeMock)
+
     // Instantiate the Encryption adapater
     const wallet = new SlpWallet()
     await wallet.walletInfoPromise
@@ -165,17 +168,53 @@ describe('#messaging-adapter', () => {
       assert.property(result, 'receiver')
       assert.property(result, 'payload')
     })
-  })
 
-  it('should catch and throw errors', async () => {
-    try {
-      await uut.generateAckMsg()
+    it('should throws error if sender is not found', async () => {
+      try {
+        const ipfsId = 'unknowPeerId'
+        const data = {
+          sender: ipfsId,
+          uuid: 'fake-uuid'
+        }
+
+        await uut.generateAckMsg(data, thisNode)
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        console.log(err)
+        assert.include(err.message, 'Required encryption information for peer is not available.')
+      }
+    })
+
+    it('should catch and throw errors', async () => {
+      try {
+        await uut.generateAckMsg()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        console.log(err)
+        assert.include(err.message, 'Cannot read')
+      }
+    })
 
-      assert.fail('Unexpected code path')
-    } catch (err) {
-      console.log(err)
-      assert.include(err.message, 'Cannot read')
-    }
+    it('should throw an error if peerData is not specified', async () => {
+      try {
+        const ipfsId = '12D3KooWHS5A6Ey4V8fLWD64jpPn2EKi4r4btGN6FfkNgMTnfqVa'
+        const data = {
+          sender: ipfsId,
+          uuid: 'fake-uuid'
+        }
+
+        thisNode.peerData = []
+
+        const result = await uut.generateAckMsg(data, thisNode)
+        console.log(result)
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'Required encryption information for peer is not available.')
+      }
+    })
   })
 
   describe('#publishToPubsubChannel', () => {

package/test/unit/adapters/pubsub/pubsub-adapter-unit.js

@@ -113,7 +113,7 @@ describe('#Adapter - Pubsub', () => {
       // Mock dependencies
       sandbox.stub(uut, 'checkForDuplicateMsg').returns(true)
 
-      const handler = () => {}
+      const handler = () => { }
 
       const msg = {
         detail: {
@@ -133,7 +133,7 @@ describe('#Adapter - Pubsub', () => {
       // Mock dependencies
       sandbox.stub(uut, 'checkForDuplicateMsg').returns(true)
 
-      const handler = () => {}
+      const handler = () => { }
 
       const msg = {
         detail: {
@@ -197,7 +197,7 @@ describe('#Adapter - Pubsub', () => {
     })
 
     it('should throw an error if data can not be parsed', async () => {
-      const handler = () => {}
+      const handler = () => { }
 
       // Force desired code path
       mockData.mockMsg.data = Buffer.from('54234', 'hex')
@@ -212,7 +212,7 @@ describe('#Adapter - Pubsub', () => {
       // Mock dependencies
       sandbox.stub(uut, 'checkForDuplicateMsg').returns(false)
 
-      const handler = () => {}
+      const handler = () => { }
 
       const msg = {
         detail: {
@@ -362,8 +362,8 @@ describe('#Adapter - Pubsub', () => {
       // sandbox.stub(uut.ipfs.ipfs.pubsub, 'subscribe').resolves()
 
       // const chanName = 'test'
-      const handler = () => {}
-      const parsePubsubMessage = async () => {}
+      const handler = () => { }
+      const parsePubsubMessage = async () => { }
 
       // Instantiate the Broadcast message router library
       const bRouterOptions = {
@@ -388,8 +388,8 @@ describe('#Adapter - Pubsub', () => {
       // sandbox.stub(uut.ipfs.ipfs.pubsub, 'subscribe').resolves()
 
       // const chanName = 'test'
-      const handler = () => {}
-      const parsePubsubMessage = async () => {}
+      const handler = () => { }
+      const parsePubsubMessage = async () => { }
 
       // Instantiate the Broadcast message router library
       const bRouterOptions = {
@@ -411,7 +411,7 @@ describe('#Adapter - Pubsub', () => {
 
     it('should catch and handle errors, and return false', async () => {
       // Force and error
-      const handler = () => {}
+      const handler = () => { }
       const parsePubsubMessage = async () => {
         throw new Error('test error')
       }
@@ -440,7 +440,7 @@ describe('#Adapter - Pubsub', () => {
       const pRouterOptions = {
         thisNode,
         messaging: uut.messaging,
-        handleNewMessage: async () => {}
+        handleNewMessage: async () => { }
       }
       const privateRouter = new PrivateChannelRouter(pRouterOptions)
 
@@ -460,7 +460,7 @@ describe('#Adapter - Pubsub', () => {
       const pRouterOptions = {
         thisNode,
         messaging: uut.messaging,
-        handleNewMessage: async () => {}
+        handleNewMessage: async () => { }
       }
       const privateRouter = new PrivateChannelRouter(pRouterOptions)
 
@@ -480,7 +480,7 @@ describe('#Adapter - Pubsub', () => {
       const pRouterOptions = {
         thisNode,
         messaging: uut.messaging,
-        handleNewMessage: async () => {}
+        handleNewMessage: async () => { }
       }
       const privateRouter = new PrivateChannelRouter(pRouterOptions)
 
@@ -516,7 +516,7 @@ describe('#Adapter - Pubsub', () => {
     it('should subscribe to the coordination channel', async () => {
       const inObj = {
         chanName: globalConfig.DEFAULT_COORDINATION_ROOM,
-        handler: () => {}
+        handler: () => { }
       }
 
       const result = await uut.subscribeToCoordChannel(inObj)
@@ -538,4 +538,33 @@ describe('#Adapter - Pubsub', () => {
       }
     })
   })
+  describe('checkForDuplicateMsg', () => {
+    it('should return true if msg is not duplicated', () => {
+      const msgMock = { detail: { sequenceNumber: 1 } }
+      const res = uut.checkForDuplicateMsg(msgMock)
+      assert.isTrue(res)
+      assert.equal(uut.trackedMsgs.length, 1)
+    })
+    it('should return falase if msg is duplicated', () => {
+      const msgMock = { detail: { sequenceNumber: 1 } }
+
+      uut.trackedMsgs = [msgMock.detail.sequenceNumber]
+      const res = uut.checkForDuplicateMsg(msgMock)
+      assert.isFalse(res)
+    })
+  })
+  describe('manageMsgCache', () => {
+    it('should shift the trackedMsgs if it exceed the limit', () => {
+      uut.TRACKED_MSG_SIZE = 2
+      uut.trackedMsgs = [1, 2, 3]
+      uut.manageMsgCache()
+      assert.equal(uut.trackedMsgs.length, 2)
+    })
+    it('should keep the trackedMsgs length if it does not exceed the limit', () => {
+      uut.TRACKED_MSG_SIZE = 4
+      uut.trackedMsgs = [1, 2, 3]
+      uut.manageMsgCache()
+      assert.equal(uut.trackedMsgs.length, 3)
+    })
+  })
 })

package/test/unit/controllers/pubsub-controller.unit.js

@@ -59,9 +59,11 @@ describe('#Pubsub-Controller', () => {
     })
 
     it('should overwrite default coinjoin channel handler', () => {
-      const coinjoinPubsubHandler = () => {}
+      const coinjoinPubsubHandler = sandbox.spy()
 
-      uut = new PubsubController({ adapters, useCases, coinjoinPubsubHandler })
+      const uut = new PubsubController({ adapters, useCases, coinjoinPubsubHandler })
+      uut.coinjoinPubsubHandler()
+      assert.isTrue(coinjoinPubsubHandler.called)
     })
   })
 
@@ -104,4 +106,12 @@ describe('#Pubsub-Controller', () => {
       assert.equal(result, false)
     })
   })
+
+  describe('#coinjoinPubsubHandler', () => {
+    it('should always return true', () => {
+      const result = uut.coinjoinPubsubHandler()
+
+      assert.equal(result, true)
+    })
+  })
 })

package/test/unit/use-cases/peer.unit.use-cases.js

@@ -262,6 +262,34 @@ describe('#Use-Cases-Peer', () => {
       // peerData array should only have one peer.
       assert.equal(uut.thisNode.peerData.length, 1)
     })
+    it('should persit the multiaddr if it exist', async () => {
+      // Mock dependencies
+      sandbox.stub(uut, 'isFreshPeer').returns(true)
+
+      const announceObj = {
+        from: 'peerId',
+        data: {
+          jsonLd: {
+            name: 'test'
+          },
+          orbitdb: 'orbitdbId'
+        },
+        multiaddr: ['/ip4/123.45.6.7/p2p/ipfs-id']
+      }
+      uut.updateThisNode({ thisNode })
+
+      // Add the new peer
+      uut.thisNode.peerList.push(announceObj.from)
+      uut.thisNode.peerData.push(announceObj)
+
+      const result = await uut.addSubnetPeer(announceObj)
+      // console.log('result: ', result)
+
+      assert.equal(result, true)
+
+      // peerData array should only have one peer.
+      assert.equal(uut.thisNode.peerData.length, 1)
+    })
 
     it('should return false if existing peer can not be found', async () => {
       // Mock dependencies
@@ -399,6 +427,13 @@ describe('#Use-Cases-Peer', () => {
 
       assert.equal(result, true)
     })
+    it('should handle Error', () => {
+      try {
+        uut.isFreshPeer(null)
+      } catch (error) {
+        assert.include(error.message, 'Cannot read properties of null')
+      }
+    })
   })
 
   describe('#refreshPeerConnections', () => {
@@ -622,6 +657,84 @@ describe('#Use-Cases-Peer', () => {
         assert.include(err.message, 'test error')
       }
     })
+    it('should update logs on fails direct connection', async () => {
+      // Add a circuit relay peer with advertised IP and port.
+      const ipfsId = 'QmbyYXKbnAmMbMGo8LRBZ58jYs58anqUzY1m4jxDmhDsje'
+      uut.thisNode.peerList = [ipfsId]
+      uut.thisNode.peerData = [{ from: ipfsId, data: { ipfsMultiaddrs: [] } }]
+
+      // Add a peer
+      await uut.addSubnetPeer(mockData.announceObj)
+
+      // Force circuit relay to be used.
+      uut.thisNode.relayData = mockData.mockRelayData
+
+      // Mock dependencies
+      sandbox.stub(uut.adapters.ipfs, 'getPeers').resolves(mockData.swarmPeers)
+      sandbox.stub(uut, 'isFreshPeer').returns(true)
+      sandbox.stub(uut.adapters.ipfs, 'connectToPeer')
+        .onCall(0).resolves({ success: false })
+        .resolves({ success: true })
+      sandbox.stub(uut.utils, 'filterMultiaddrs').returns(['/ip4/123.45.6.7/p2p/ipfs-id'])
+      sandbox.stub(uut, 'updatePeerConnectionInfo').returns()
+
+      // Connect to that peer.
+      const result = await uut.refreshPeerConnections()
+
+      assert.equal(result, true)
+    })
+    it('should connect to circuit relay ', async () => {
+      // Add a circuit relay peer with advertised IP and port.
+      const ipfsId = 'QmbyYXKbnAmMbMGo8LRBZ58jYs58anqUzY1m4jxDmhDsje'
+      uut.thisNode.peerList = [ipfsId]
+      uut.thisNode.peerData = [{ from: ipfsId, data: { ipfsMultiaddrs: ['/p2p-circuit/ip4/123.45.6.7/tcp/4001/p2p/ipfs-id'] } }]
+
+      // Add a peer
+      await uut.addSubnetPeer(mockData.announceObj)
+
+      // Force circuit relay to be used.
+      uut.thisNode.relayData = mockData.mockRelayData
+
+      // Mock dependencies
+      sandbox.stub(uut.adapters.ipfs, 'getPeers').resolves(mockData.swarmPeers)
+      sandbox.stub(uut, 'isFreshPeer').returns(true)
+      sandbox.stub(uut.adapters.ipfs, 'connectToPeer')
+        .onCall(0).resolves({ success: false })
+        .resolves({ success: true })
+      sandbox.stub(uut.utils, 'filterMultiaddrs').returns(['/ip4/123.45.6.7/p2p/ipfs-id'])
+      sandbox.stub(uut, 'updatePeerConnectionInfo').returns()
+
+      // Connect to that peer.
+      const result = await uut.refreshPeerConnections()
+
+      assert.equal(result, true)
+    })
+    it('should update logs on fails circuit relay connection', async () => {
+      // Add a circuit relay peer with advertised IP and port.
+      const ipfsId = 'QmbyYXKbnAmMbMGo8LRBZ58jYs58anqUzY1m4jxDmhDsje'
+      uut.thisNode.peerList = [ipfsId]
+      uut.thisNode.peerData = [{ from: ipfsId, data: { ipfsMultiaddrs: ['/p2p-circuit/ip4/123.45.6.7/tcp/4001/p2p/ipfs-id'] } }]
+
+      // Add a peer
+      await uut.addSubnetPeer(mockData.announceObj)
+
+      // Force circuit relay to be used.
+      uut.thisNode.relayData = mockData.mockRelayData
+
+      // Mock dependencies
+      sandbox.stub(uut.adapters.ipfs, 'getPeers').resolves(mockData.swarmPeers)
+      sandbox.stub(uut, 'isFreshPeer').returns(true)
+      sandbox.stub(uut.adapters.ipfs, 'connectToPeer')
+        .onCall(0).resolves({ success: false })
+        .resolves({ success: false })
+      sandbox.stub(uut.utils, 'filterMultiaddrs').returns(['/ip4/123.45.6.7/p2p/ipfs-id'])
+      sandbox.stub(uut, 'updatePeerConnectionInfo').returns()
+
+      // Connect to that peer.
+      const result = await uut.refreshPeerConnections()
+
+      assert.equal(result, true)
+    })
   })
 
   describe('#sendRPC', () => {
@@ -733,4 +846,102 @@ describe('#Use-Cases-Peer', () => {
       assert.equal(result, false)
     })
   })
+
+  describe('#updatePeerConnectionInfo', () => {
+    it('should update the peer connection info', async () => {
+      uut.thisNode.peerData = [{ from: 'peerId' }]
+      sandbox.stub(uut.adapters.ipfs.ipfs.libp2p, 'getConnections').returns([{ remoteAddr: '/ip4/123.45.6.7/p2p/ipfs-id' }])
+      const result = await uut.updatePeerConnectionInfo({ thisPeer: 'peerId' })
+      assert.equal(result, true)
+      assert.equal(uut.thisNode.peerData[0].multiaddr, '/ip4/123.45.6.7/p2p/ipfs-id')
+    })
+    it('should return false if the peer is not connected', async () => {
+      uut.thisNode.peerData = [{ from: 'peerId' }]
+      sandbox.stub(uut.adapters.ipfs.ipfs.libp2p, 'getConnections').returns([])
+      const result = await uut.updatePeerConnectionInfo({ thisPeer: 'peerId' })
+      assert.equal(result, false)
+    })
+    it('should return false if the peer is not found', async () => {
+      uut.thisNode.peerData = [{ from: 'peerId' }]
+      sandbox.stub(uut.adapters.ipfs.ipfs.libp2p, 'getConnections').returns([{ remoteAddr: '/ip4/123.45.6.7/p2p/ipfs-id' }])
+      const result = await uut.updatePeerConnectionInfo({ thisPeer: 'peerId2' })
+      assert.equal(result, false)
+    })
+    it('should handle errors', async () => {
+      try {
+        uut.thisNode.peerData = [{ from: 'peerId' }]
+        sandbox.stub(uut.adapters.ipfs.ipfs.libp2p, 'getConnections').throws(new Error('test error'))
+        await uut.updatePeerConnectionInfo({ thisPeer: 'peerId' })
+        assert.fail('Unexpected code path')
+      } catch (error) {
+        assert.include(error.message, 'test error')
+      }
+    })
+  })
+  describe('#getWebRtcMultiaddr', () => {
+    it('should return the webRTC multiaddr', async () => {
+      const thisNodeMock = thisNode
+      const webRtcMultiaddr1 = '/ip4/127.0.0.1/tcp/5000/ws/p2p-circuit/webrtc/p2p/ipfs-id'
+      const webRtcMultiaddr2 = '/ip4/127.0.0.1/tcp/5001/ws/p2p-circuit/webrtc/p2p/ipfs-id2'
+
+      thisNodeMock.ipfsMultiaddrs = ['/ip4/123.45.6.7/p2p/ipfs-id', webRtcMultiaddr1, webRtcMultiaddr2]
+      sandbox.stub(uut.adapters.ipfs.ipfs.libp2p, 'getMultiaddrs').returns([webRtcMultiaddr2])
+
+      await uut.getWebRtcMultiaddr({ thisNode: thisNodeMock })
+
+      assert.equal(thisNodeMock.ipfsMultiaddrs.length, 2)
+      assert.equal(thisNodeMock.ipfsMultiaddrs[0], '/ip4/123.45.6.7/p2p/ipfs-id')
+      assert.equal(thisNodeMock.ipfsMultiaddrs[1], webRtcMultiaddr2, 'expected webRTC multiaddr to be updated')
+    })
+    it('should return false on error', async () => {
+      const result = await uut.getWebRtcMultiaddr(null)
+      assert.equal(result, false)
+    })
+  })
+  describe('#getMultiaddrs', () => {
+    it('should filter multiaddrs with a low chance of success', async () => {
+      const webRtcMultiaddr1 = '/ip4/157.178.192.100/tcp/5000/ws/p2p-circuit/webrtc/p2p/ipfs-id'
+      const lowChanceMultiaddrsExamples = [
+        '/ip4/127.0.0.1/tcp/4001/p2p/QmHash', // localhost
+        '/ip4/192.168.1.100/tcp/4001/p2p/QmHash', // private network (192.168.x.x)
+        '/ip4/172.16.0.100/tcp/4001/p2p/QmHash', // private network (172.16-31.x.x)
+        '/ip4/10.0.0.100/tcp/4001/p2p/QmHash', // private network (10.x.x.x)
+        '/ip4/1.2.3.4/p2p/4001/quic/p2p/QmHash', // QUIC protocol
+        '/ip4/1.2.3.4/udp/4001/p2p/QmHash', // UDP protocol
+        '/ip4/192.168.0.100/udp/4001/quic/p2p/QmHash', // private network with QUIC
+        '/ip4/172.20.0.100/udp/4001/p2p/QmHash' // private network with UDP
+
+      ]
+      sandbox.stub(uut.adapters.ipfs.ipfs.libp2p, 'getMultiaddrs').returns([...lowChanceMultiaddrsExamples, webRtcMultiaddr1])
+      const result = await uut.getMultiaddrs()
+      assert.equal(result.length, 1)
+      assert.equal(result[0], webRtcMultiaddr1)
+    })
+    it('should return empty array on error', async () => {
+      sandbox.stub(uut.adapters.ipfs.ipfs.libp2p, 'getMultiaddrs').throws(new Error('test error'))
+      const result = await uut.getMultiaddrs()
+      assert.equal(result.length, 0)
+    })
+  })
+  describe('relayMetricsHandler', () => {
+    it('should return true', async () => {
+      uut.incomingData = 'data'
+      await uut.relayMetricsHandler('updated data')
+      assert.equal(uut.incomingData, 'updated data')
+    })
+  })
+
+  describe('updateThisNode', () => {
+    it('should update the thisNode object', async () => {
+      const thisNodeMock = { data: 'mock node' }
+      const result = await uut.updateThisNode({ thisNode: thisNodeMock })
+      assert.equal(result, true)
+      assert.equal(uut.thisNode.data, 'mock node')
+    })
+    it('should keep as default if no data is provided', async () => {
+      const result = await uut.updateThisNode()
+      assert.equal(result, true)
+      assert.isUndefined(uut.thisNode)
+    })
+  })
 })

package/test/unit/use-cases/pubsub.unit.use-cases.js

@@ -107,6 +107,22 @@ describe('#pubsub-Use-Cases', () => {
 
       assert.equal(result, true)
     })
+    it('should throw an error if controllers are not provided', async () => {
+      try {
+        sandbox.stub(uut.adapters.pubsub, 'subscribeToCoordChannel').resolves()
+
+        uut.updateThisNode({
+          pubsubChannels: []
+        })
+
+        await uut.initializePubsub()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        // console.log(err)
+        assert.include(err.message, 'Instance of controllers must be passed to initializePubsub()')
+      }
+    })
 
     it('should catch and throw an error', async () => {
       try {

package/test/unit/use-cases/relay-use-cases-unit.js

@@ -172,6 +172,35 @@ describe('#relay-Use-Cases', () => {
       // Assert function executed successfully.
       assert.equal(result, true)
     })
+    it('Should debug when relay connection is not over tcp', async () => {
+      // Add a relay that is not over tcp
+      thisNode.relayData.push(
+        {
+          multiaddr:
+            '/ip4/139.162.76.54/udp/5269/ws/p2p/QmaKzQTAtoJWYMiG5ATx41uWsMajr1kSxRdtg919s8fK77',
+          connected: true,
+          updatedAt: '2021-09-20T15:59:12.961Z',
+          ipfsId: 'QmaKzQTAtoJWYMiG5ATx41uWsMajr1kSxRdtg919s8fK77',
+          isBootstrap: false,
+          metrics: { aboutLatency: [] },
+          latencyScore: 10000
+        }
+      )
+
+      // Mock dependencies
+      sandbox.stub(uut, 'sortRelays').returns(thisNode.relayData)
+      sandbox.stub(uut.adapters.ipfs, 'getPeers').resolves(mockData.connectedPeerList01)
+      sandbox.stub(uut.adapters.ipfs, 'connectToPeer').resolves({ success: true })
+      sandbox.stub(uut.adapters.ipfs.ipfs.libp2p, 'getConnections').returns([{
+        remoteAddr: '/ip4/116.203.193.74/udp/4001/ipfs/QmNZktxkfScScnHCFSGKELH3YRqdxHQ3Le9rAoRLhZ6vgL/p2p-circuit'
+      }])
+
+      // uut.state.relays = crMockData.circuitRelays
+      const result = await uut.connectToCRs(thisNode)
+
+      // Assert function executed successfully.
+      assert.equal(result, true)
+    })
 
     it('Should skip relays that are already connected', async () => {
       // Force circuit relay to be used.
@@ -246,7 +275,7 @@ describe('#relay-Use-Cases', () => {
       sandbox.stub(uut, 'sortRelays').returns(thisNode.relayData)
       sandbox.stub(uut.adapters.ipfs, 'getPeers').resolves(mockData.connectedPeerList01)
       sandbox.stub(uut.adapters.ipfs.ipfs.libp2p, 'getConnections').returns([{
-        remoteAddr: '/ip4/116.203.193.74/tcp/4001/ipfs/QmNZktxkfScScnHCFSGKELH3YRqdxHQ3Le9rAoRLhZ6vgL'
+        remoteAddr: '/ip4/116.203.193.74/tcp/4001/ipfs/QmNZktxkfScScnHCFSGKELH3YRqdxHQ3Le9rAoRLhZ6vgL/p2p-circuit'
       }])
 
       // uut.state.relays = crMockData.circuitRelays
@@ -269,6 +298,85 @@ describe('#relay-Use-Cases', () => {
 
       assert.equal(result, false)
     })
+
+    it('Should log when CR is connected through another CR, and does not have a tcp transport', async () => {
+      // Force relay data to have a p2p-circuit multiaddr
+      // mockData.mockRelayData[0].multiaddr = '/ip4/116.203.193.74/tcp/4001/ipfs/QmNZktxkfScScnHCFSGKELH3YRqdxHQ3Le9rAoRLhZ6vgL'
+      mockData.mockRelayData[0].multiaddr = '/ip4/116.203.193.74/udp/4001/ipfs/QmNZktxkfScScnHCFSGKELH3YRqdxHQ3Le9rAoRLhZ6vgL/p2p-circuit/p2p/QmNZktxkfScScnHCFSGKELH3YRqdxHQ3Le9rAoRLhZ6vgL'
+
+      // Force circuit relay to be used.
+      thisNode.relayData = mockData.mockRelayData
+
+      // Force mock circuit relay to appear as being already connected.
+      mockData.connectedPeerList01.push(mockData.mockRelayData[0].ipfsId)
+
+      // Force entity data with implicit multiaddr, which will will overwrite
+      // the explicit multiaddr provided by the realy.
+      thisNode.peerData.push({
+        from: 'QmNZktxkfScScnHCFSGKELH3YRqdxHQ3Le9rAoRLhZ6vgL',
+        data: {
+          connectionAddr: 'fake-multiaddr'
+        }
+      })
+
+      // Mock dependencies
+      sandbox.stub(uut, 'sortRelays').returns(thisNode.relayData)
+      sandbox.stub(uut.adapters.ipfs, 'getPeers').resolves(mockData.connectedPeerList01)
+      sandbox.stub(uut.adapters.ipfs.ipfs.libp2p, 'getConnections').returns([{
+        remoteAddr: '/ip4/116.203.193.74/udp/4001/ipfs/QmNZktxkfScScnHCFSGKELH3YRqdxHQ3Le9rAoRLhZ6vgL/p2p-circuit/p2p/QmNZktxkfScScnHCFSGKELH3YRqdxHQ3Le9rAoRLhZ6vgL'
+      }])
+
+      // uut.state.relays = crMockData.circuitRelays
+      const result = await uut.connectToCRs(thisNode)
+
+      console.log('thisNode.peerData: ', thisNode.peerData)
+
+      // Assert function executed successfully.
+      assert.equal(result, true)
+
+      // Assert that the multiaddr was overwritten
+      // assert.include(thisNode.peerData[0].data.connectionAddr, 'tcp')
+    })
+
+    it('Should log when CR makes a new connection through another CR, and does not have a tcp transport', async () => {
+      // Force relay data to have a p2p-circuit multiaddr
+      // mockData.mockRelayData[0].multiaddr = '/ip4/116.203.193.74/tcp/4001/ipfs/QmNZktxkfScScnHCFSGKELH3YRqdxHQ3Le9rAoRLhZ6vgL'
+      mockData.mockRelayData[0].multiaddr = '/ip4/116.203.193.74/udp/4001/ipfs/QmNZktxkfScScnHCFSGKELH3YRqdxHQ3Le9rAoRLhZ6vgL/p2p-circuit/p2p/QmNZktxkfScScnHCFSGKELH3YRqdxHQ3Le9rAoRLhZ6vgL'
+
+      // Force circuit relay to be used.
+      thisNode.relayData = mockData.mockRelayData
+
+      // Force mock circuit relay to appear as being already connected.
+      // mockData.connectedPeerList01.push(mockData.mockRelayData[0].ipfsId)
+
+      // Force entity data with implicit multiaddr, which will will overwrite
+      // the explicit multiaddr provided by the realy.
+      thisNode.peerData.push({
+        from: 'QmNZktxkfScScnHCFSGKELH3YRqdxHQ3Le9rAoRLhZ6vgL',
+        data: {
+          connectionAddr: 'fake-multiaddr'
+        }
+      })
+
+      // Mock dependencies
+      sandbox.stub(uut, 'sortRelays').returns(thisNode.relayData)
+      sandbox.stub(uut.adapters.ipfs, 'getPeers').resolves(mockData.connectedPeerList01)
+      sandbox.stub(uut.adapters.ipfs.ipfs.libp2p, 'getConnections').returns([{
+        remoteAddr: '/ip4/116.203.193.74/udp/4001/ipfs/QmNZktxkfScScnHCFSGKELH3YRqdxHQ3Le9rAoRLhZ6vgL/p2p-circuit/p2p/QmNZktxkfScScnHCFSGKELH3YRqdxHQ3Le9rAoRLhZ6vgL'
+      }])
+      sandbox.stub(uut.adapters.ipfs, 'connectToPeer').resolves({ success: true })
+
+      // uut.state.relays = crMockData.circuitRelays
+      const result = await uut.connectToCRs(thisNode)
+
+      console.log('thisNode.peerData: ', thisNode.peerData)
+
+      // Assert function executed successfully.
+      assert.equal(result, true)
+
+      // Assert that the multiaddr was overwritten
+      // assert.include(thisNode.peerData[0].data.connectionAddr, 'tcp')
+    })
   })
 
   describe('#addRelay', () => {
@@ -628,7 +736,7 @@ describe('#relay-Use-Cases', () => {
 
       // Mock dependencies
       sandbox.stub(uut.adapters.bch.bchjs.Util, 'sleep').resolves()
-      sandbox.stub(uut.adapters.pubsub.about, 'queryAbout').resolves(true)
+      sandbox.stub(uut.peerUseCases, 'queryAbout').resolves(true)
 
       await uut.measureRelays(thisNode)
       // console.log(
@@ -674,6 +782,33 @@ describe('#relay-Use-Cases', () => {
       // First element of '1' should have been shifted out and replaced by '2'
       assert.equal(thisNode.relayData[0].metrics.aboutLatency[0], 2)
     })
+
+    it('should ignore a broken peer data', async () => {
+      // Mock test data
+      const thisNode = {
+        relayData: [
+          {
+            ipfsId: 'testId',
+            isBootstrap: false,
+            connected: false,
+            metrics: {
+              aboutLatency: []
+            }
+          }
+        ],
+        peerData: [
+
+          {
+            data: null
+          }
+        ]
+      }
+
+      await uut.measureRelays(thisNode)
+      // console.log('thisNode: ', thisNode)
+
+      assert.equal(thisNode.relayData[0].metrics.aboutLatency.length, 0)
+    })
   })
 
   describe('#sortRelays', () => {