helia-coord 1.1.0

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

@@ -0,0 +1,146 @@
+/*
+  Use cases for interacting with subnet peer nodes.
+*/
+
+class PeerUseCases {
+  constructor (localConfig = {}) {
+    // Dependency Injection.
+    this.adapters = localConfig.adapters
+    if (!this.adapters) {
+      throw new Error(
+        'Must inject instance of adapters when instantiating Peer Use Cases library.'
+      )
+    }
+  }
+
+  // Connect to a peer through available circuit relays. This ensures a short
+  // path between peers, *before* broadcasting the OrbitDB message to them.
+  // This method is primarily used by sendPrivateMessage() to allow for fast-
+  // startup connection and communication with peers.
+  async connectToPeer (peerId, thisNode) {
+    try {
+      // console.log(`connectToPeer() called on ${peerId}`)
+
+      const relays = thisNode.relayData
+
+      // Get connected peers
+      const connectedPeers = await this.adapters.ipfs.getPeers()
+
+      // Check if target peer is currently conected to the node.
+      const connectedPeer = connectedPeers.filter(
+        peerObj => peerObj.peer === peerId
+      )
+
+      // If this node is already connected to the peer, then return.
+      // We do not need to do anything.
+      if (connectedPeer.length) {
+        return true
+      }
+
+      // Sort the Circuit Relays by the average of the aboutLatency
+      // array. Connect to peers through the Relays with the lowest latencies
+      // first.
+      const sortedRelays = thisNode.useCases.relays.sortRelays(relays)
+      // console.log(`sortedRelays: ${JSON.stringify(sortedRelays, null, 2)}`)
+
+      // Loop through each known circuit relay and attempt to connect to the
+      // peer through a relay.
+      for (let i = 0; i < sortedRelays.length; i++) {
+        const thisRelay = sortedRelays[i]
+        // console.log(`thisRelay: ${JSON.stringify(thisRelay, null, 2)}`)
+
+        // Generate a multiaddr for connecting to the peer through a circuit relay.
+        const multiaddr = `${thisRelay.multiaddr}/p2p-circuit/p2p/${peerId}`
+        // console.log(`multiaddr: ${multiaddr}`)
+
+        // Skip the relay if this node is not connected to it.
+        if (thisRelay.connected) {
+          // Attempt to connect to the node through a circuit relay.
+          const connected = await this.adapters.ipfs.connectToPeer(multiaddr)
+
+          // If the connection was successful, break out of the relay loop.
+          // Otherwise try to connect through the next relay.
+          if (connected) {
+            // Exit once we've made a successful connection.
+            return true
+          }
+        }
+      }
+
+      // Return false to indicate connection was unsuccessful.
+      return false
+    } catch (err) {
+      console.error('Error in peer-use-cases.js/connectToPeer()')
+      throw err
+    }
+  }
+
+  // Publish a string of text to another peers OrbitDB recieve database.
+  // orbitdbId input is optional.
+  async sendPrivateMessage (peerId, str, thisNode) {
+    try {
+      // console.log('sendPrivateMessage() peerId: ', peerId)
+      // console.log('\nsendPrivateMessage() str: ', str)
+
+      // const peer = this.peers.state.peers[peerId]
+      // console.log('thisNode.peerData: ', thisNode.peerData)
+      const peerData = thisNode.peerData.filter(x => x.from === peerId)
+      // console.log(
+      //   `sendPrivateMessage peerData: ${JSON.stringify(peerData, null, 2)}`
+      // )
+
+      // Throw an error if the peer matching the peerId is not found.
+      if (peerData.length === 0) {
+        throw new Error(`Data for peer ${peerId} not found.`)
+      }
+
+      // Encrypt the string with the peers public key.
+      const encryptedStr = await this.adapters.encryption.encryptMsg(
+        peerData[0],
+        str
+      )
+
+      // Publish the message to the peers pubsub channel.
+      await this.adapters.pubsub.messaging.sendMsg(
+        peerId,
+        encryptedStr,
+        thisNode
+      )
+      // console.log('--->Successfully published to pubsub channel<---')
+
+      // const now = new Date()
+      //
+      // const peerDb = thisNode.orbitData.filter(x => x.ipfsId === peerId)
+      // // console.log('peerDb: ', peerDb)
+      //
+      // // Throw an error if peer database was not found.
+      // if (peerDb.length === 0) {
+      //   throw new Error(`OrbitDB for peer ${peerId} not found.`)
+      // }
+      //
+      // // Connect to peer through Circuit Relay, using connectToPeer()
+      // // Note: isConnected will resolve to false if this node can not connect to
+      // // the peer. It will resolve to true if it successfully connected.
+      // await this.connectToPeer(peerId, thisNode)
+      //
+      // const db = peerDb[0].db
+      //
+      // const dbObj = {
+      //   from: thisNode.ipfsId,
+      //   data: encryptedStr,
+      //   timestamp: now.toISOString()
+      // }
+      // // console.log(`dbObj: ${JSON.stringify(dbObj, null, 2)}`)
+      //
+      // // Add the encrypted message to the peers OrbitDB.
+      // await db.add(dbObj)
+
+      return true
+    } catch (err) {
+      console.error('Error in peer-use-cases.js/sendPrivateMessage(): ', err)
+      throw err
+    }
+  }
+}
+
+export default PeerUseCases

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

@@ -0,0 +1,56 @@
+/*
+  A Use Case library for interacting with the Pubsub Entity.
+*/
+
+const DEFAULT_COORDINATION_ROOM = 'psf-ipfs-coordination-002'
+const BCH_COINJOIN_ROOM = 'bch-coinjoin-001'
+
+class PubsubUseCase {
+  constructor (localConfig = {}) {
+    // Dependency Injection.
+    this.adapters = localConfig.adapters
+    if (!this.adapters) {
+      throw new Error(
+        'Must inject instance of adapters when instantiating Pubsub Use Cases library.'
+      )
+    }
+    this.thisNodeUseCases = localConfig.thisNodeUseCases
+    if (!this.thisNodeUseCases) {
+      throw new Error(
+        'thisNode use cases required when instantiating Pubsub Use Cases library.'
+      )
+    }
+
+    // Allow the app to override the default CoinJoin pubsub handler.
+    this.coinjoinPubsubHandler = () => true
+    if (localConfig.coinjoinPubsubHandler) this.coinjoinPubsubHandler = localConfig.coinjoinPubsubHandler
+  }
+
+  // Connect to the default pubsub rooms.
+  async initializePubsub (thisNode) {
+    try {
+      // Subscribe to the coordination channel, where new peers announce themselves
+      // to the network.
+      await this.adapters.pubsub.subscribeToPubsubChannel(
+        DEFAULT_COORDINATION_ROOM,
+        // this.adapters.peers.addPeer
+        this.thisNodeUseCases.addSubnetPeer,
+        thisNode
+      )
+
+      // Subscribe to the BCH CoinJoin coordination channel. This code is here
+      // so that Circuit Relays automatically subscribe to the channel and
+      // relay the messages.
+      await this.adapters.pubsub.subscribeToPubsubChannel(
+        BCH_COINJOIN_ROOM,
+        this.coinjoinPubsubHandler,
+        thisNode
+      )
+    } catch (err) {
+      console.error('Error in pubsub-use-cases.js/initializePubsub()')
+      throw err
+    }
+  }
+}
+
+export default PubsubUseCase

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

@@ -0,0 +1,479 @@
+/*
+  A Use Case library for working with Circuit Relays.
+
+  TODO: Build these methods:
+  - pruneConnections() - Disconnect dead or misbehaving nodes.
+  - addRelay() - Add a new relay to the state.
+*/
+
+import bootstrapCircuitRelays from '../../config/bootstrap-circuit-relays.js'
+// const RelayEntity = require('../entities/relay-entity')
+
+class RelayUseCases {
+  constructor (localConfig = {}) {
+    // Dependency Injection.
+    this.adapters = localConfig.adapters
+    if (!this.adapters) {
+      throw new Error(
+        'Must inject instance of adapters when instantiating Relay Use Cases library.'
+      )
+    }
+    // this.controllers = localConfig.controllers
+    // if (!this.controllers) {
+    //   throw new Error(
+    //     'Must inject instance of controllers when instantiating Relay Use Cases library.'
+    //   )
+    // }
+  }
+
+  // Connect to the pre-programmed circuit relays for the first time at startup.
+  async initializeRelays (thisNode) {
+    try {
+      // Set the initial CR bootstrap nodes based on the type of IPFS node.
+      let bootstrapRelays = []
+      if (thisNode.type === 'browser') {
+        bootstrapRelays = bootstrapCircuitRelays.browser
+      } else {
+        bootstrapRelays = bootstrapCircuitRelays.node
+      }
+
+      // Loop through each bootstrap Relay.
+      for (let i = 0; i < bootstrapRelays.length; i++) {
+        const thisRelay = bootstrapRelays[i]
+
+        // Attempt to connect to the Circuit Relay peer.
+        const connectionStatus = await this.adapters.ipfs.connectToPeer(
+          thisRelay.multiaddr
+        )
+
+        const now = new Date()
+
+        const newRelayObj = {
+          multiaddr: thisRelay.multiaddr,
+          connected: connectionStatus,
+          updatedAt: now,
+          ipfsId: thisRelay.ipfsId,
+          isBootstrap: true,
+          metrics: {
+            aboutLatency: []
+          }
+        }
+
+        // Record relay information in thisNode entity.
+        thisNode.relayData.push(newRelayObj)
+      }
+
+      return true
+    } catch (err) {
+      console.error('Error in relay-use-case.js/initializeRelays()')
+      throw err
+    }
+  }
+
+  // Download a list of Circuit Relays from a GitHub Gist, and try to connect
+  // to all of the ones in the list.
+  async getCRGist (thisNode) {
+    try {
+      const gistCRs = await this.adapters.gist.getCRList()
+
+      let gistRelays
+      if (thisNode.type === 'browser') {
+        gistRelays = gistCRs.browser
+      } else {
+        gistRelays = gistCRs.node
+      }
+
+      console.log(`Relays from the gist: ${JSON.stringify(gistRelays, null, 2)}`)
+
+      for (let i = 0; i < gistRelays.length; i++) {
+        const thisRelay = gistRelays[i]
+
+        // If this relay is already in the list of circuit relays, then skip.
+        const alreadyExists = thisNode.relayData.filter(
+          x => x.ipfsId === thisRelay.ipfsId
+        )
+        if (alreadyExists.length) continue
+
+        // Attempt to connect to the Circuit Relay peer.
+        console.log(`getCRGist() Connecting to Circuit Relay ${thisRelay.multiaddr}`)
+        const connectionStatus = await this.adapters.ipfs.connectToPeer(
+          thisRelay.multiaddr
+        )
+
+        const now = new Date()
+
+        const newRelayObj = {
+          multiaddr: thisRelay.multiaddr,
+          connected: connectionStatus,
+          updatedAt: now,
+          ipfsId: thisRelay.ipfsId,
+          isBootstrap: false,
+          metrics: {
+            aboutLatency: []
+          }
+        }
+
+        // Record relay information in thisNode entity.
+        thisNode.relayData.push(newRelayObj)
+      }
+
+      // Remove duplicate Circuit Relays.
+      await this.removeDuplicates(thisNode)
+
+      return true
+    } catch (err) {
+      console.error('Error in relay-use-case.js/getCRGist()')
+      throw err
+    }
+  }
+
+  // Renew the connection to each circuit relay in the state.
+  async connectToCRs (thisNode) {
+    try {
+      let knownRelays = thisNode.relayData
+
+      // Sort the Relays by their latency. This way Relays with the lowest latency
+      // (relative to thisNode) are used first.
+      knownRelays = this.sortRelays(knownRelays)
+      // console.log('knownRelays: ', knownRelays)
+
+      for (let i = 0; i < knownRelays.length; i++) {
+        const thisRelay = knownRelays[i]
+        // console.log('thisRelay: ', thisRelay)
+
+        // Get connected peers
+        const connectedPeers = await this.adapters.ipfs.getPeers()
+        // console.log('connectedPeers: ', connectedPeers)
+
+        // Check if target circuit-relay is currently conected to the node.
+        const connectedPeer = connectedPeers.filter(peerObj => thisRelay.multiaddr.match(peerObj.peer)
+        )
+        // console.log('connectedPeer: ', connectedPeer)
+
+        // Update the connection state.
+
+        if (connectedPeer.length) {
+          // Already connected.
+          thisRelay.connected = true
+          console.log(`Already connected to Circuit Relay ${thisRelay.multiaddr}`)
+        } else {
+          // If this node is not connected, try to connect again.
+          console.log(`Connecting to Circuit Relay ${thisRelay.multiaddr}`)
+          thisRelay.connected = await this.adapters.ipfs.connectToPeer(
+            thisRelay.multiaddr
+          )
+          console.log(`thisRelay.connected: ${thisRelay.connected}`)
+
+          if (thisRelay.connected) {
+            this.adapters.log.statusLog(
+              0,
+              `Connected to Circuit Relay peer ${thisRelay.ipfsId}`
+            )
+            console.log(`connectToCRs() Connected to Circuit Relay peer ${thisRelay.ipfsId}`)
+          }
+        }
+        // console.log('thisRelay.connected: ', thisRelay.connected)
+
+        // Update the timestamp.
+        const now = new Date()
+        thisRelay.updatedAt = now
+
+        // Update the state tracked by This Node.
+        thisNode.relayData[i] = thisRelay
+      }
+
+      // const now = new Date()
+      // this.adapters.log.statusLog(
+      //   `status: ${now.toLocaleString()}: Renewed connections to all known Circuit Relay nodes.`
+      // )
+    } catch (err) {
+      console.log('Error in connectToCRs()')
+      return false
+    }
+  }
+
+  // Sort the relay data relative to the measured latency metrics.
+  sortRelays (relayData) {
+    try {
+      // Loop through each element and add a latency score.
+      for (let i = 0; i < relayData.length; i++) {
+        const thisRelay = relayData[i]
+
+        // Ensure an initial default value is assigned.
+        thisRelay.latencyScore = 10000
+
+        // Assign bootstrap nodes the maximum latency.
+        if (thisRelay.isBootstrap) {
+          thisRelay.latencyScore = 10000
+        } else {
+          // Average the latencies measured for this Relay.
+          thisRelay.latencyScore = Math.floor(
+            this._average(thisRelay.metrics.aboutLatency)
+          )
+
+          // Handle corner-case of empty arrays.
+          if (isNaN(thisRelay.latencyScore)) thisRelay.latencyScore = 10000
+        }
+
+      // console.log('thisRelay: ', thisRelay)
+      }
+
+      // Sort the array by the latency score.
+      // https://flaviocopes.com/how-to-sort-array-of-objects-by-property-javascript/
+      const sortedList = relayData.sort((a, b) => a.latencyScore > b.latencyScore ? 1 : -1
+      )
+      // console.log('Relay sortedList: ', sortedList)
+
+      return sortedList
+    } catch (err) {
+      console.error('Error in sortRelays()')
+      throw err
+    }
+  }
+
+  // Average together the elements of an array.
+  _average (arr) {
+    return arr.reduce((p, c) => p + c, 0) / arr.length
+  }
+
+  // If a subnet Peer has the isCircuitRelay flag set, try to connect to them
+  // directly. If the connection succeeds, add them to the list of Circuit Relays.
+  // Triggered when a new subnet peer is found that has their Relay flag set.
+  async addRelay (ipfsId, thisNode) {
+    try {
+      const now = new Date()
+      // console.log(`debug: addRelay() called at ${now.toLocaleString()}`)
+
+      // Check to see if peer is already in the list of Circuit Relays.
+      const alreadyInList = thisNode.relayData.filter(x => x.ipfsId.includes(ipfsId)
+      )
+      // Exit if this peer is already in the list of Relays.
+      if (alreadyInList.length) return true
+
+      // this.adapters.log.statusLog(1, 'New Circuit Relay Peer Found!')
+
+      // Get the peer data.
+      let peerData = thisNode.peerData.filter(x => x.data.ipfsId === ipfsId)
+      peerData = peerData[0]
+      // console.log('peerData: ', peerData)
+
+      // Exit if this peer is not a circuit relay.
+      // CT Added 9/4/21.
+      // Added because testing was showing that some non-relay peers where getting
+      // pings with about metrics.
+      const isCircuitRelay = peerData.data.isCircuitRelay
+      if (!isCircuitRelay) return false // Return true?
+
+      this.adapters.log.statusLog(
+        1,
+        `New Circuit Relay Peer Found: ${peerData.from}`
+      )
+
+      // Grab the optional connection information if the Circuit Relay provides
+      // it. If they do, construct a connection string and add it to the
+      // list of multiaddrs.
+      const circuitRelayInfo = peerData.data.circuitRelayInfo
+      if (circuitRelayInfo) {
+        if (circuitRelayInfo.ip4) {
+          const ip4TcpMultiaddr = `/ip4/${circuitRelayInfo.ip4}/tcp/${circuitRelayInfo.tcpPort}/p2p/${peerData.from}`
+          peerData.data.ipfsMultiaddrs.push(ip4TcpMultiaddr)
+        }
+        if (circuitRelayInfo.crDomain) {
+          const dnsMultiaddr = `/dns4/${circuitRelayInfo.crDomain}/tcp/443/wss/ipfs/${peerData.from}`
+          peerData.data.ipfsMultiaddrs.push(dnsMultiaddr)
+        }
+
+      // Debugging
+      // console.log(
+      //   `peer multiaddrs: ${JSON.stringify(
+      //     peerData.data.ipfsMultiaddrs,
+      //     null,
+      //     2
+      //   )}`
+      // )
+      }
+
+      let multiaddr = ''
+      let connectSuccess = false
+
+      // Try to connect to one of the multiaddrs.
+      for (let i = 0; i < peerData.data.ipfsMultiaddrs.length; i++) {
+        const thisAddr = peerData.data.ipfsMultiaddrs[i]
+        // console.log('thisAddr: ', thisAddr)
+
+        // Try to connect to the IPFS peer.
+        connectSuccess = await this.adapters.ipfs.connectToPeer(thisAddr)
+
+        // If connection was successful
+        if (connectSuccess) {
+          // Get a list of connect peers.
+          const peers = await this.adapters.ipfs.getPeers()
+          // console.log('addRelay() peers: ', peers)
+
+          // Retrieve the multiaddr that worked for connecting.
+          const thisRelay = peers.filter(x => x.peer.toString() === ipfsId)
+          // console.log('thisRelay: ', thisRelay)
+          multiaddr = thisRelay[0].addr.toString()
+          // console.log('multiaddr: ', multiaddr)
+
+          // If multiaddr does not contain ip4, ip6, or dns, then reject it,
+          // because the connection is happening through another Relay.
+          // If the multiaddr has 'p2p-circuit' in it, then it's also happening
+          // through a Relay and should be rejected.
+          const isIp4 = multiaddr.includes('ip4')
+          const isIp6 = multiaddr.includes('ip6')
+          const isDns = multiaddr.includes('dns')
+          const isBridged = multiaddr.includes('p2p-circuit')
+          if ((!isIp4 && !isIp6 && !isDns) || isBridged) {
+            this.adapters.log.statusLog(
+              1,
+              `Rejecting Relay multiaddr ${multiaddr}`
+            )
+
+            // Disconnect from the peer, so that a direct connection can be
+            // attempted.
+            await this.adapters.ipfs.disconnectFromPeer(ipfsId)
+
+            connectSuccess = false
+            continue
+          }
+
+          break
+        } else {
+          this.adapters.log.statusLog(
+            1,
+            `Connecting to potential relay did not succeed with multiaddr ${thisAddr}`
+          )
+        }
+      }
+
+      // If we could not successfully connect to the peer with any of the given
+      // multiaddrs, then do not add it to the list of Relays.
+      if (!connectSuccess) {
+        this.adapters.log.statusLog(
+          1,
+          `: Could not add potential Circuit Relay: ${ipfsId}`
+        )
+        return false
+      }
+
+      // Add tail end of multiaddr if it's omitted. (this happens in go-ipfs v0.11.0)
+      if (!multiaddr.includes(ipfsId)) {
+        multiaddr = `${multiaddr}/p2p/${ipfsId}`
+      }
+
+      // On successful connection, add the Circuit Relay to the list.
+      // const now = new Date()
+      const newRelayObj = {
+        multiaddr,
+        connected: true,
+        updatedAt: now,
+        ipfsId,
+        isBootstrap: false,
+        metrics: {
+          aboutLatency: []
+        }
+      }
+      // console.log(`newRelayObj: ${JSON.stringify(newRelayObj, null, 2)}`)
+      thisNode.relayData.push(newRelayObj)
+
+      console.log(`New Circuit Relay added: ${multiaddr}`)
+
+      return true
+    } catch (err) {
+      console.error('Error in addRelay(): ', err)
+      // top-level function. Do not throw an error.
+      return false
+    }
+  }
+
+  // Called when periodically checking the Relay connection. Maintains network
+  // metrics about each Relay.
+  // Called by the manageCircuitRelays() Timer Controller.
+  async measureRelays (thisNode) {
+    try {
+      // console.log('Entering measureRelays()')
+      // console.log('thisNode.relayData: ', thisNode.relayData)
+      // console.log(
+      //   `thisNode.peerData: ${JSON.stringify(thisNode.peerData, null, 2)}`
+      // )
+
+      // Loop through each Circuit Relay
+      for (let i = 0; i < thisNode.relayData.length; i++) {
+        const thisRelay = thisNode.relayData[i]
+
+        // If the relay is from the bootstrap list, skip it.
+        // if (thisRelay.isBootstrap) continue
+
+        // Get the peer data.
+        let peerData = thisNode.peerData.filter(x => {
+          // console.log(`x.data.ipfsId: ${x.data.ipfsId}`)
+          // console.log(`thisRelay.ipfsId: ${thisRelay.ipfsId}`)
+          return x.data.ipfsId === thisRelay.ipfsId
+        })
+        peerData = peerData[0]
+        // console.log(`peerData: ${JSON.stringify(peerData, null, 2)}`)
+
+        // Skip if this Relay is not advertising as a relay.
+        if (!peerData || !peerData.data.isCircuitRelay) continue
+
+        // console.log(`peerData: ${JSON.stringify(peerData, null, 2)}`)
+
+        // If this node is not connected to the Relay, give it the worst score.
+        if (!thisRelay.connected) {
+          thisRelay.metrics.aboutLatency.push(10000)
+          continue
+        }
+
+        // Poll the /about JSON endpoint, and track the time it takes to recieve
+        // a response.
+        const startTime = new Date()
+        const testResult = await this.adapters.pubsub.about.queryAbout(
+          thisRelay.ipfsId,
+          thisNode
+        )
+        // await this.adapters.bch.bchjs.Util.sleep(2000)
+        const endTime = new Date()
+
+        let diffTime = 10000
+        if (testResult) diffTime = endTime.getTime() - startTime.getTime()
+        // console.log(`Time difference: ${diffTime} mS`)
+
+        // Prune the metrics array if it's too big.
+        if (thisRelay.metrics.aboutLatency.length > 9) {
+          thisRelay.metrics.aboutLatency.shift()
+        }
+
+        // Save the new metric value.
+        thisRelay.metrics.aboutLatency.push(diffTime)
+      }
+    } catch (err) {
+      console.error('Error in measureRelays(): ', err)
+      throw err
+    }
+  }
+
+  // Remove any duplicate entries of Circuit Relays.
+  // This is middleware that edits the thisNode.relayData in place.
+  removeDuplicates (thisNode) {
+    try {
+      const startingRelays = thisNode.relayData
+      // console.log('thisNode.relayData: ', thisNode.relayData)
+
+      // https://stackoverflow.com/questions/2218999/how-to-remove-all-duplicates-from-an-array-of-objects
+      const endingRelays = startingRelays.filter(
+        (relay, index, self) => index === self.findIndex(t => t.ipfsId === relay.ipfsId)
+      )
+      // console.log('endingRelays: ', endingRelays)
+
+      thisNode.relayData = endingRelays
+
+      return true
+    } catch (err) {
+      console.error('Error in removeDuplicates()')
+      throw err
+    }
+  }
+}
+
+export default RelayUseCases