helia-coord 1.1.0

package/.on-save.json

@@ -0,0 +1,8 @@
+[
+  {
+    "srcDir": "",
+    "destDir": "",
+    "files": "**/*.js",
+    "command": "npm run lint"
+  }
+]

package/PEDIGREE.md

@@ -0,0 +1,3 @@
+# Pedigree
+
+This repository was forked from [ipfs-coord-esm](https://github.com/Permissionless-Software-Foundation/ipfs-coord-esm). Code changes from that upstream repository is frequently pulled in and merged to this repository.

package/README.md

@@ -0,0 +1,3 @@
+# 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.

package/config/bootstrap-circuit-relays.js

@@ -0,0 +1,48 @@
+/*
+  This library contains known circuit relays that new IPFS nodes can use to
+  bootstrap themselves into the network and join the pubsub network.
+*/
+/* eslint camelcase: 0 */
+
+const BOOTSTRAP_BROWSER_CRs = [
+  {
+    // Based in USA, east coast.
+    name: 'bchd.nl',
+    multiaddr: '/dns4/bchd.nl/tcp/443/wss/p2p/12D3KooWRBhwfeP2Y9CDkFRBAZ1pmxUadH36TKuk3KtKm5XXP8mA',
+    connected: false,
+    ipfsId: '12D3KooWRBhwfeP2Y9CDkFRBAZ1pmxUadH36TKuk3KtKm5XXP8mA',
+    isBootstrap: true
+  },
+  {
+    name: 'ipfs-cr.fullstackslp.nl',
+    multiaddr: '/dns4/ipfs-cr.fullstackslp.nl/tcp/443/wss/p2p/12D3KooWJyc54njjeZGbLew4D8u1ghrmZTTPyh3QpBF7dxtd3zGY',
+    connected: false,
+    ipfsId: '12D3KooWJyc54njjeZGbLew4D8u1ghrmZTTPyh3QpBF7dxtd3zGY',
+    isBootstrap: true
+  }
+]
+
+const BOOTSTRAP_NODE_CRs = [
+  {
+    name: 'bchd.nl',
+    multiaddr: '/ip4/5.161.95.233/tcp/4001/p2p/12D3KooWRBhwfeP2Y9CDkFRBAZ1pmxUadH36TKuk3KtKm5XXP8mA',
+    connected: false,
+    ipfsId: '12D3KooWRBhwfeP2Y9CDkFRBAZ1pmxUadH36TKuk3KtKm5XXP8mA',
+    isBootstrap: true
+  },
+  {
+    name: 'ipfs-cr.fullstackslp.nl',
+    multiaddr: '/ip4/78.46.129.7/tcp/4001/p2p/12D3KooWJyc54njjeZGbLew4D8u1ghrmZTTPyh3QpBF7dxtd3zGY',
+    connected: false,
+    ipfsId: '12D3KooWJyc54njjeZGbLew4D8u1ghrmZTTPyh3QpBF7dxtd3zGY',
+    isBootstrap: true
+  }
+]
+
+const bootstrapCircuitRelays = {
+  browser: BOOTSTRAP_BROWSER_CRs,
+  node: BOOTSTRAP_NODE_CRs
+}
+
+// module.exports = bootstrapCircuitRelays
+export default bootstrapCircuitRelays

package/examples/start-external.js

@@ -0,0 +1,56 @@
+/*
+  This example shows how to start an IPFS node, using ipfs-coord, with the
+  IPFS node running as an external node that can be controlled via the
+  ipfs-http-client library.
+
+  Designed to use IPFS running in this Docker container:
+  https://github.com/christroutner/docker-ipfs
+*/
+
+// const IPFS = require('@chris.troutner/ipfs')
+import { create } from 'ipfs-http-client'
+// const IPFS = require('/home/trout/work/personal/js-ipfs/packages/ipfs')
+// const BCHJS = require('@psf/bch-js')
+import SlpWallet from 'minimal-slp-wallet'
+// const IpfsCoord = require('ipfs-coord')
+import IpfsCoord from '../index.js'
+import http from 'http'
+
+// Configuration for external IPFS node.
+const ipfsOptions = {
+  protocol: 'http',
+  host: 'localhost',
+  port: 5001,
+  agent: http.Agent({ keepAlive: true, maxSockets: 100 })
+}
+
+async function start () {
+  // Create an instance of bch-js and IPFS.
+  // const bchjs = new BCHJS()
+  const wallet = new SlpWallet()
+  await wallet.walletInfoPromise
+  const ipfs = await create(ipfsOptions)
+
+  // 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.')
+
+  // Used for debugging
+  // setTimeout(async function () {
+  //   const thisNode = ipfsCoord.thisNode
+  //   console.log('\nthisNode: ', thisNode)
+  //   // console.log(
+  //   //   `thisNode.peerData: ${JSON.stringify(thisNode.peerData, null, 2)}`
+  //   // )
+  // }, 20000)
+}
+start()

package/index.js

@@ -0,0 +1,129 @@
+/*
+  A JS npm library for helping IPFS peers coordinate, find a common interest,
+  and stay connected around that interest.
+
+  See the specification document in the dev-docs directory.
+*/
+
+// Local libraries
+import Adapters from './lib/adapters/index.js'
+import UseCases from './lib/use-cases/index.js'
+import Controllers from './lib/controllers/index.js'
+
+class IpfsCoord {
+  constructor (localConfig = {}) {
+    // Dependency Injection
+    if (!localConfig.ipfs) {
+      throw new Error(
+        'An instance of IPFS must be passed when instantiating the ipfs-coord library.'
+      )
+    }
+    if (!localConfig.wallet) {
+      throw new Error(
+        'An instance of minimal-slp-wallet must be passed when instantiating the ipfs-coord library.'
+      )
+    }
+    this.type = localConfig.type
+    if (!this.type) {
+      throw new Error(
+        'The type of IPFS node (browser or node.js) must be specified.'
+      )
+    }
+
+    // Retrieve and/or set the debug level.
+    // 0 = no debug information.
+    // 1 = status logs
+    // 2 = verbose errors about peer connections
+    this.debugLevel = parseInt(localConfig.debugLevel)
+    if (!this.debugLevel) this.debugLevel = 0
+    localConfig.debugLevel = this.debugLevel
+    console.log(`ipfs-coord debug level: ${localConfig.debugLevel}`)
+
+    // localConfiguration of an optional 'status' log handler for log reports. If none
+    // is specified, defaults to console.log.
+    if (localConfig.statusLog) {
+      this.statusLog = localConfig.statusLog
+    } else {
+      this.statusLog = console.log
+    }
+    // If the statusLog handler wasn't specified, then define it.
+    localConfig.statusLog = this.statusLog
+
+    // localConfiguration of an optional 'private' log handler for recieving e2e
+    // encrypted message. If none is specified, default to console.log.
+    if (localConfig.privateLog) {
+      this.privateLog = localConfig.privateLog
+    } else {
+      this.privateLog = console.log
+    }
+    // If the privateLog handler wasn't specified, then define it.
+    localConfig.privateLog = this.privateLog
+
+    // Load the adapter libraries.
+    this.adapters = new Adapters(localConfig)
+    localConfig.adapters = this.adapters
+
+    // Load the Use Cases
+    this.useCases = new UseCases(localConfig)
+    localConfig.useCases = this.useCases
+
+    // Load Controllers
+    this.controllers = new Controllers(localConfig)
+  }
+
+  // Returns a Promise that resolves to true once the IPFS node has been
+  // initialized and has had a chance to connect to circuit relays and
+  // coordination pubsub channels.
+  async start () {
+    // Wait for the IPFS to finish initializing, then retrieve information
+    // about the node like it's ID and multiaddrs.
+    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.
+    this.thisNode = await this.useCases.thisNode.createSelf({ type: this.type })
+    // console.log('thisNode: ', this.thisNode)
+
+    // Subscribe to Pubsub Channels
+    await this.useCases.pubsub.initializePubsub(this.thisNode)
+
+    // Start timer-based controllers.
+    await this.controllers.timer.startTimers(this.thisNode, this.useCases)
+
+    // Kick-off initial connection to Circuit Relays and Peers.
+    // Note: Deliberatly *not* using await here, so that it doesn't block startup
+    // of ipfs-service-provider.
+    this._initializeConnections()
+
+    return true
+  }
+
+  // This function kicks off initial connections to the circuit relays and then
+  // peers. This function is intended to be called once at startup. This handles
+  // the initial connections, but the timer-controller manages the connections
+  // 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()
+      console.log('Initial connections to subnet Peers complete.')
+
+      return true
+    } catch (err) {
+      console.error('Error in _initializeConnections(): ', err)
+      // throw err
+
+      // Do not throw errors as it will prevent the node from starting.
+      return false
+    }
+  }
+}
+
+export default IpfsCoord

package/lib/adapters/bch-adapter.js

@@ -0,0 +1,94 @@
+/*
+  A top level library for Bitcoin Cash (BCH) handling. This library will
+  encapsulate a lot of support libraries and contain BCH-specific methods.
+*/
+
+class BchAdapter {
+  constructor (localConfig) {
+    // Dependency Injection
+    if (!localConfig.wallet) {
+      throw new Error(
+        'An instance of minimal-slp-wallet must be passed when instantiating the BCH adapter library.'
+      )
+    }
+
+    this.bchjs = localConfig.wallet.bchjs
+    this.mnemonic = localConfig.wallet.walletInfo.mnemonic
+  }
+
+  // Generate a BCH key pair and address. Returns an object with this information,
+  // which can be used for payments and e2e encryption.
+  // 12-word mnemonic string input is optional. Will generate a new wallet and
+  // keypair if not provided. Will use the first address on the SLIP44
+  // derivation path of 245 if a 12 word mnemonic is provided.
+  async generateBchId () {
+    try {
+      // Generate a 12-word mnemonic, if one isn't provided.
+      // if (!this.mnemonic) {
+      //   this.mnemonic = this.bchjs.Mnemonic.generate(
+      //     128,
+      //     this.bchjs.Mnemonic.wordLists().english
+      //   )
+      // }
+      // console.log(`mnemonic: ${mnemonic}`)
+
+      // root seed buffer
+      const rootSeed = await this.bchjs.Mnemonic.toSeed(this.mnemonic)
+
+      const masterHDNode = this.bchjs.HDNode.fromSeed(rootSeed)
+
+      const childNode = masterHDNode.derivePath("m/44'/245'/0'/0/0")
+
+      const outObj = {}
+
+      // Generate the cash and SLP addresses.
+      outObj.cashAddress = this.bchjs.HDNode.toCashAddress(childNode)
+      outObj.slpAddress = this.bchjs.SLP.Address.toSLPAddress(
+        outObj.cashAddress
+      )
+
+      // No need to export the private key?
+      // outObj.WIF = this.bchjs.HDNode.toWIF(childNode)
+
+      // Export the public key as a hex string. This will be used for e2e
+      // encryption.
+      const pubKey = this.bchjs.HDNode.toPublicKey(childNode)
+      outObj.publicKey = pubKey.toString('hex')
+
+      return outObj
+    } catch (err) {
+      console.error('Error in bch-lib.js/generateBchId()')
+      throw err
+    }
+  }
+
+  async generatePrivateKey () {
+    try {
+      // Generate a 12-word mnemonic, if one isn't provided.
+      // if (!this.mnemonic) {
+      //   this.mnemonic = this.bchjs.Mnemonic.generate(
+      //     128,
+      //     this.bchjs.Mnemonic.wordLists().english
+      //   )
+      // }
+      // console.log(`mnemonic: ${mnemonic}`)
+
+      // root seed buffer
+      const rootSeed = await this.bchjs.Mnemonic.toSeed(this.mnemonic)
+
+      const masterHDNode = this.bchjs.HDNode.fromSeed(rootSeed)
+
+      const childNode = masterHDNode.derivePath("m/44'/245'/0'/0/0")
+
+      const privKey = this.bchjs.HDNode.toWIF(childNode)
+
+      return privKey
+    } catch (err) {
+      console.error('Error in bch-lib.js/generatePrivateKey()')
+      throw err
+    }
+  }
+}
+
+// module.exports = BchAdapter
+export default BchAdapter

package/lib/adapters/encryption-adapter.js

@@ -0,0 +1,123 @@
+/*
+  A library for end-to-end encryption (e2ee). This will largely be a wrapper
+  for existing encryption libraries.
+*/
+
+import BchEncrypt from 'bch-encrypt-lib/index.js'
+
+class EncryptionAdapter {
+  constructor (localConfig = {}) {
+    // Dependency injection
+    this.bch = localConfig.bch
+    if (!this.bch) {
+      throw new Error(
+        'Must pass in an instance of bch Adapter when instantiating the encryption Adapter library.'
+      )
+    }
+    this.bchjs = this.bch.bchjs // Copy of bch-js
+
+    this.bchEncrypt = new BchEncrypt({ bchjs: this.bchjs })
+    // this.ipfs = encryptConfig.ipfs
+    // this.orbitdb = encryptConfig.orbitdb
+  }
+
+  // Decrypt incoming messages on the pubsub channel for this node.
+  async decryptMsg (msg) {
+    try {
+      // console.log('decryptMsg msgObj: ', msg)
+
+      const privKey = await this.bch.generatePrivateKey()
+      // console.log(`privKey: ${privKey}`)
+
+      const decryptedHexStr = await this.bchEncrypt.encryption.decryptFile(
+        privKey,
+        msg
+      )
+      // console.log(`decryptedHexStr ${decryptedHexStr}`)
+
+      const decryptedBuff = Buffer.from(decryptedHexStr, 'hex')
+
+      const decryptedStr = decryptedBuff.toString()
+      // console.log(`decryptedStr: ${decryptedStr}`)
+
+      return decryptedStr
+    } catch (err) {
+      // Exit quietly if the issue is a 'Bad MAC'. This seems to be a startup
+      // issue.
+      if (err.message.includes('Bad MAC')) {
+        throw new Error(
+          'Bad MAC. Could not decrypt message. Peer may have stale encryption data for this node.'
+        )
+        // return ''
+      }
+
+      console.error('Error in decryptMsg()')
+      throw err
+    }
+  }
+
+  // Returns an encrypted hexidecimal string derived from an input message
+  // (string), encrypted with the public key of a peer.
+  async encryptMsg (peer, msg) {
+    try {
+      // console.log('peer: ', peer)
+
+      const pubKey = peer.data.encryptPubKey
+      // console.log('msg to encrypt: ', msg)
+      // console.log(`Encrypting with public key: ${pubKey}`)
+
+      const msgBuf = Buffer.from(msg, 'utf8').toString('hex')
+
+      const encryptedHexStr = await this.bchEncrypt.encryption.encryptFile(
+        pubKey,
+        msgBuf
+      )
+
+      return encryptedHexStr
+    } catch (err) {
+      console.error('Error in encryption.js/encryptMsg()')
+      throw err
+    }
+  }
+
+  // Send an e2e encrypted message to a peer.
+  // async sendEncryptedMsg (peer, msg) {
+  //   try {
+  //     // console.log('sendEncryptedMsg peer: ', peer)
+  //     // console.log('sendEncryptedMsg msg: ', msg)
+  //
+  //     // const channel = peer.ipfsId.toString()
+  //     const pubKey = peer.encryptPubKey
+  //     // const orbitdbId = peer.orbitdb
+  //
+  //     const msgBuf = Buffer.from(msg, 'utf8').toString('hex')
+  //     // console.log(`msgBuf: ${msgBuf}`)
+  //
+  //     const encryptedHexStr = await this.bchEncrypt.encryption.encryptFile(
+  //       pubKey,
+  //       msgBuf
+  //     )
+  //     console.log(`encryptedHexStr: ${encryptedHexStr}`)
+  //
+  //     // const msgBuf2 = Buffer.from(encryptedHexStr, 'hex')
+  //
+  //     // Publish the message to the pubsub channel.
+  //     // TODO: This will be deprecated in the future in favor of publishing to
+  //     // the peers OrbitDB.
+  //     // await this.ipfs.pubsub.publish(channel, msgBuf2)
+  //
+  //     // if (orbitdbId) {
+  //     //   console.log(
+  //     //     `Ready to send encrypted message to peer ${channel} on orbitdb ID ${orbitdbId}`
+  //     //   )
+  //     //   await this.orbitdb.sendToDb(channel, encryptedHexStr, orbitdbId)
+  //     // }
+  //   } catch (err) {
+  //     console.error('Error in sendEncryptedMsg()')
+  //     throw err
+  //   }
+  // }
+}
+
+// module.exports = EncryptionAdapter
+export default EncryptionAdapter

package/lib/adapters/gist.js

@@ -0,0 +1,42 @@
+/*
+  This adapter library is concerned with interfacing with the GitHub Gist API.
+  It's used to download a more easily maintained list of Circuit Relays
+  operated by members of the PSF.
+*/
+
+import axios from 'axios'
+
+class Gist {
+  constructor (localConfig = {}) {
+    this.axios = axios
+  }
+
+  // Retrieve a JSON file from a GitHub Gist
+  async getCRList () {
+    try {
+      // Public CRs
+      // https://gist.github.com/christroutner/048ea1a4b635a055c6bb63d48c373806
+      const gistUrl =
+        'https://api.github.com/gists/048ea1a4b635a055c6bb63d48c373806'
+
+      // Retrieve the gist from github.com.
+      const result = await this.axios.get(gistUrl)
+      // console.log('result.data: ', result.data)
+
+      // Get the current content of the gist.
+      const content = result.data.files['psf-public-circuit-relays.json'].content
+      // console.log('content: ', content)
+
+      // Parse the JSON string into an Object.
+      const object = JSON.parse(content)
+      // console.log('object: ', object)
+
+      return object
+    } catch (err) {
+      console.error('Error attempting to download GitHub Gist of alternative servers.')
+      throw err
+    }
+  }
+}
+
+export default Gist

package/lib/adapters/index.js

@@ -0,0 +1,66 @@
+/*
+  This is a top-level library for the Adapters. This file loads all other
+  adapter libraries.
+*/
+
+// Public npm libraries
+// const EventEmitter = require('events')
+// EventEmitter.defaultMaxListeners = 200
+
+// Local libraries
+import LogsAdapter from './logs-adapter.js'
+import BchAdapter from './bch-adapter.js'
+import IpfsAdapter from './ipfs-adapter.js'
+import EncryptionAdapter from './encryption-adapter.js'
+import PubsubAdapter from './pubsub-adapter/index.js'
+import Gist from './gist.js'
+
+// const Gist = require('./gist')
+
+class Adapters {
+  constructor (localConfig = {}) {
+    // Dependency injection
+    if (!localConfig.ipfs) {
+      throw new Error(
+        'An instance of IPFS must be passed when instantiating the Adapters library.'
+      )
+    }
+    if (!localConfig.wallet) {
+      throw new Error(
+        'An instance of minimal-slp-wallet must be passed when instantiating the Adapters library.'
+      )
+    }
+
+    // Input Validation
+    if (!localConfig.type) {
+      throw new Error(
+        'The type of IPFS node (browser or node.js) must be specified.'
+      )
+    }
+
+    // BEGIN: Encapsulate dependencies
+
+    // Some adapter libraries depend on other adapter libraries. Pass them
+    // in the localConfig object.
+
+    this.log = new LogsAdapter(localConfig)
+    localConfig.log = this.log
+
+    this.bch = new BchAdapter(localConfig)
+    localConfig.bch = this.bch
+
+    this.ipfs = new IpfsAdapter(localConfig)
+    localConfig.ipfsAdapter = this.ipfs
+
+    this.encryption = new EncryptionAdapter(localConfig)
+    localConfig.encryption = this.encryption
+
+    this.pubsub = new PubsubAdapter(localConfig)
+    this.gist = new Gist(localConfig)
+
+  // END: Encapsulate dependencies
+  }
+}
+
+// module.exports = Adapters
+export default Adapters