Merge pull request #13 from Permissionless-Software-Foundation/ct-unstable

fix(cors): slight tweak to avoid CORS error

.gitignore

@@ -7,6 +7,7 @@
 #logs
 logs/*.json
 *.log
+*.log.*
 npm-debug.log*
 
 # Runtime data
@@ -65,5 +66,7 @@ system-user-*.json
 orbitdb
 ipfsdata
 .ipfsdata
+run-dev.sh
+data/
 
 !README.md

bin/server.js

@@ -68,6 +68,10 @@ class Server {
       app.use(passport.initialize())
       app.use(passport.session())
 
+      // Enable CORS for testing
+      // THIS IS A SECURITY RISK. COMMENT OUT FOR PRODUCTION
+      app.use(cors({ origin: '*' }))
+
       // Attach REST API and JSON RPC controllers to the app.
       const Controllers = require('../src/controllers')
       const controllers = new Controllers()
@@ -75,10 +79,6 @@ class Server {
 
       app.controllers = controllers
 
-      // Enable CORS for testing
-      // THIS IS A SECURITY RISK. COMMENT OUT FOR PRODUCTION
-      app.use(cors({ origin: '*' }))
-
       // MIDDLEWARE END
 
       console.log(`Running server in environment: ${config.env}`)
@@ -104,8 +104,18 @@ class Server {
       return app
     } catch (err) {
       console.error('Could not start server. Error: ', err)
+
+      console.log(
+        'Exiting after 5 seconds. Depending on process manager to restart.'
+      )
+      await sleep(5000)
+      process.exit(1)
     }
   }
 }
 
+function sleep (ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
 module.exports = Server

config/env/common.js

@@ -15,7 +15,7 @@ const ipfsCoordName = process.env.COORD_NAME
 
 module.exports = {
   // Configure TCP port.
-  port: process.env.PORT || 5001,
+  port: process.env.PORT || 5005,
 
   // Password for HTML UI that displays logs.
   logPass: 'test',
@@ -72,17 +72,31 @@ module.exports = {
   },
 
   // IPFS Ports
-  ipfsTcpPort: process.env.IPFS_TCP_PORT ? process.env.IPFS_TCP_PORT : 4001,
-  ipfsWsPort: process.env.IPFS_WS_PORT ? process.env.IPFS_WS_PORT : 4003,
+  ipfsTcpPort: process.env.IPFS_TCP_PORT ? process.env.IPFS_TCP_PORT : 4101,
+  ipfsWsPort: process.env.IPFS_WS_PORT ? process.env.IPFS_WS_PORT : 4103,
 
   // BCH Mnemonic for generating encryption keys and payment address
   mnemonic: process.env.MNEMONIC ? process.env.MNEMONIC : '',
 
   debugLevel: process.env.DEBUG_LEVEL ? parseInt(process.env.DEBUG_LEVEL) : 2,
 
+  // Preferred provider running ipfs-bch-wallet-service for BCH wallet.
   preferredProvider: process.env.PREFERRED_PROVIDER
     ? process.env.PREFERRED_PROVIDER
-    : 'QmdBGB8S6sEr19gaAxJYjhRbz5ZmMiH5a1JyyMmaxcRKnY'
+    : '',
+  //  : 'QmdBGB8S6sEr19gaAxJYjhRbz5ZmMiH5a1JyyMmaxcRKnY'
   // : 'QmUTx6KqYKVZbKpKxR7vGDUgZFYVvVVyEWDeCYq4GwBCff'
   // Used for development
+
+  // Preferred P2WDB provider
+  preferredP2wdbProvider: process.env.PREFERRED_P2WDB_PROVIDER
+    ? process.env.PREFERRED_P2WDB_PROVIDER
+    : '',
+
+  // Settings for production, using external go-ipfs node.
+  isProduction: process.env.SVC_ENV === 'production' ? true : false,
+  ipfsHost: process.env.IPFS_HOST ? process.env.IPFS_HOST : 'localhost',
+  ipfsApiPort: process.env.IPFS_API_PORT
+    ? parseInt(process.env.IPFS_API_PORT)
+    : 5001
 }

config/env/development.js

@@ -7,6 +7,6 @@
 module.exports = {
   session: 'secret-boilerplate-token',
   token: 'secret-jwt-token',
-  database: 'mongodb://localhost:27017/ipfs-service-dev',
+  database: 'mongodb://localhost:27017/ipfs-bch-consumer-dev',
   env: 'dev'
 }

config/env/production.js

@@ -13,6 +13,6 @@ module.exports = {
   // database: 'mongodb://172.17.0.1:5555/ipfs-service-prod',
   database: process.env.DBURL
     ? process.env.DBURL
-    : 'mongodb://172.17.0.1:5555/ipfs-service-prod',
+    : 'mongodb://172.17.0.1:5555/ipfs-bch-consumer-prod',
   env: 'prod'
 }

config/env/test.js

@@ -7,6 +7,6 @@
 module.exports = {
   session: 'secret-boilerplate-token',
   token: 'secret-jwt-token',
-  database: 'mongodb://localhost:27017/ipfs-service-test',
+  database: 'mongodb://localhost:27017/ipfs-bch-consumer-test',
   env: 'test'
 }

config/index.js

@@ -1,6 +1,6 @@
 const common = require('./env/common')
 
-const env = process.env.SVC_ENV || 'development'
+const env = process.env.CONSUMER_ENV || 'development'
 const config = require(`./env/${env}`)
 
 module.exports = Object.assign({}, common, config)

package.json

@@ -6,14 +6,14 @@
   "scripts": {
     "start": "node index.js",
     "test": "npm run test:all",
-    "test:all": "export SVC_ENV=test && nyc --reporter=text mocha --exit --timeout 15000 --recursive test/unit test/e2e/automated/",
-    "test:unit": "export SVC_ENV=test && mocha --exit --timeout 15000 --recursive test/unit/",
-    "test:e2e:auto": "export SVC_ENV=test && mocha --exit --timeout 15000 test/e2e/automated/",
-    "test:temp": "export SVC_ENV=test && mocha --exit --timeout 15000 -g '#rate-limit' test/unit/json-rpc/",
+    "test:all": "export CONSUMER_ENV=test && nyc --reporter=text mocha --exit --timeout 15000 --recursive test/unit test/e2e/automated/",
+    "test:unit": "export CONSUMER_ENV=test && mocha --exit --timeout 15000 --recursive test/unit/",
+    "test:e2e:auto": "export CONSUMER_ENV=test && mocha --exit --timeout 15000 test/e2e/automated/",
+    "test:temp": "export CONSUMER_ENV=test && mocha --exit --timeout 15000 -g '#rate-limit' test/unit/json-rpc/",
     "lint": "standard --env mocha --fix",
     "docs": "./node_modules/.bin/apidoc -i src/ -o docs",
     "coverage": "nyc report --reporter=text-lcov | coveralls",
-    "coverage:report": "export SVC_ENV=test && nyc --reporter=html mocha --exit --timeout 15000 --recursive test/unit/ test/e2e/automated/"
+    "coverage:report": "export CONSUMER_ENV=test && nyc --reporter=html mocha --exit --timeout 15000 --recursive test/unit/ test/e2e/automated/"
   },
   "author": "Chris Troutner <chris.troutner@gmail.com>",
   "license": "MIT",
@@ -23,12 +23,13 @@
   },
   "repository": "Permissionless-Software-Foundation/ipfs-bch-wallet-consumer",
   "dependencies": {
-    "@chris.troutner/ipfs": "2.0.2",
-    "@psf/bch-js": "4.20.26",
+    "@psf/bch-js": "4.20.28",
     "axios": "0.21.1",
     "bcryptjs": "2.4.3",
     "glob": "7.1.6",
-    "ipfs-coord": "6.7.4",
+    "ipfs": "0.60.0",
+    "ipfs-coord": "6.8.10",
+    "ipfs-http-client": "55.0.0",
     "jsonrpc-lite": "2.2.0",
     "jsonwebtoken": "8.5.1",
     "jwt-bch-lib": "1.3.0",
@@ -42,7 +43,7 @@
     "koa-passport": "4.1.3",
     "koa-router": "10.0.0",
     "koa-static": "5.0.0",
-    "koa2-ratelimit": "0.9.0",
+    "koa2-ratelimit": "0.9.1",
     "line-reader": "0.4.0",
     "mongoose": "5.11.15",
     "node-fetch": "npm:@achingbrain/node-fetch@2.6.7",
@@ -64,6 +65,7 @@
     "eslint-plugin-prettier": "3.3.1",
     "eslint-plugin-standard": "4.0.0",
     "husky": "4.3.8",
+    "lodash.clonedeep": "^4.5.0",
     "mocha": "8.2.1",
     "nyc": "15.1.0",
     "semantic-release": "17.4.4",

production/docker/Dockerfile

@@ -33,8 +33,8 @@ WORKDIR /home/safeuser
 #RUN runuser -l safeuser -c "npm config set prefix '~/.npm-global'"
 
 # Update to the latest version of npm.
-# Working with npm@7.21.1
-RUN npm install -g npm@7.23.0
+#RUN npm install -g npm@7.23.0
+RUN npm install -g npm
 
 # npm mirror to prevent direct dependency on npm.
 RUN npm set registry http://94.130.170.209:4873/
@@ -66,7 +66,7 @@ RUN npm run docs
 VOLUME /home/safeuser/keys
 
 # Expose the port the API will be served on.
-EXPOSE 5001
+EXPOSE 5010
 
 # Start the application.
 COPY start-production.sh start-production.sh

production/docker/README.md

@@ -0,0 +1,61 @@
+# Docker Containers
+
+The 'production' environment is assumed to be a set of Docker containers orchestrated with Docker Compose. The files in this directory will stand up three Docker containers:
+
+1 An instance of go-ipfs.
+2 An instance of MongoDB.
+3 The JavaScript software in this repository.
+
+The software in this repository depends on the first two containers, so if they aren't running correctly, the application won't run correctly either.
+
+## IPFS
+
+IPFS can be a little tricky to set up. By default, the container uses the following ports:
+
+- 4001 for TCP connections, exposed publicly.
+- 5001 for control by the application, exposed privately.
+- 8080 for an IPFS gateway, consumed by the application, exposed privately.
+
+If you already have an IPFS node running on a the computer, you will need to change the ports to avaid a conflict. To change the ports from the default, you'll need to perform a series of steps, and the order of the steps matter.
+
+1. Edit the `docker-compose.yml` file and change the ports. Then save the file. Here is an example:
+
+```
+ports:
+  - 4101:4101
+  - 172.17.0.1:5101:5101
+  - 172.17.0.1:8180:8180
+```
+
+2. Bring the Docker containers up, and then back down. This will allow the IPFS container to create the config file that you'll need to edit.
+
+- `docker-compose up -d`
+- Wait a few seconds.
+- `docker-compose down`
+
+3. Update the generated config file at `../data/go-ipfs/data/config`, to update the ports in the config file, like this:
+
+```
+"Addresses": {
+    "API": "/ip4/0.0.0.0/tcp/5101",
+    "Announce": [],
+    "AppendAnnounce": [],
+    "Gateway": "/ip4/0.0.0.0/tcp/8180",
+    "NoAnnounce": [],
+    "Swarm": [
+      "/ip4/0.0.0.0/tcp/4101",
+      "/ip6/::/tcp/4101",
+      "/ip4/0.0.0.0/udp/4101/quic",
+      "/ip6/::/udp/4101/quic"
+    ]
+  },
+
+```
+
+4. Update the port changes in the `start-production.sh` shell script. This tells the application which ports to use, in order to control the IPFS node, are are used when signaling other nodes.
+
+5. Quickly rebuild the containers, to add the modified `start-production.sh` shell script to the application Docker container:
+
+- `docker-compose build`
+
+6. Now start the containers, and the port changes to IPFS should be complete.

production/docker/docker-compose.yml

@@ -1,6 +1,6 @@
 # Start the service with the command 'docker-compose up -d'
 
-version: '2'
+version: '3.9'
 
 services:
   mongo-ipfs-service:
@@ -13,6 +13,35 @@ services:
     command: mongod --logpath=/dev/null # -- quiet
     restart: always
 
+  ipfs:
+    image: ipfs/go-ipfs:v0.11.0
+    container_name: ipfs
+    environment:
+      MY_ENV_VAR: 'placeholder'
+    logging:
+      driver: 'json-file'
+      options:
+        max-size: '10m'
+        max-file: '10'
+    mem_limit: 2000mb
+    ports:
+      - 4001:4001
+      - 172.17.0.1:5001:5001
+      - 172.17.0.1:8080:8080
+    volumes:
+      - ../data/go-ipfs/data:/data/ipfs
+      - ../data/go-ipfs/export:/export
+    # https://docs.docker.com/compose/compose-file/compose-file-v3/#command
+    # https://github.com/ipfs/go-ipfs/blob/91c52657166bcf86f2476926e4fe56694dc26562/Dockerfile#L115
+    command:
+      [
+        'daemon',
+        '--migrate=true',
+        '--agent-version-suffix=docker',
+        '--enable-pubsub-experiment'
+      ]
+    restart: always
+
   ipfs-service:
     build: .
     container_name: ipfs-service
@@ -24,10 +53,9 @@ services:
     mem_limit: 500mb
     links:
       - mongo-ipfs-service
+      - ipfs
     ports:
-      - '5001:5001' # <host port>:<container port>
-      - '5268:5268' # IPFS TCP
-      - '5269:5269' # IPFS WS
+      - '5010:5010' # <host port>:<container port>
     volumes:
       - ../data/ipfsdata:/home/safeuser/ipfs-service-provider/.ipfsdata
     restart: always

production/docker/start-production.sh

@@ -17,7 +17,7 @@ export COORD_NAME=ipfs-service-provider-generic
 #export CR_DOMAIN=subdomain.yourdomain.com
 
 # Debug level. 0 = minimal info. 2 = max info.
-export DEBUG_LEVEL=1
+export DEBUG_LEVEL=2
 
 # END: Optional configuration settings
 
@@ -25,13 +25,14 @@ export DEBUG_LEVEL=1
 # Production database connection string.
 export DBURL=mongodb://172.17.0.1:5555/ipfs-service-prod
 
-# Configure IPFS ports
-export IPFS_TCP_PORT=5268
-export IPFS_WS_PORT=5269
-
-
 # Configure REST API port
-export PORT=5001
+export PORT=5010
 
+# Production settings using external go-ipfs node.
 export SVC_ENV=production
+export IPFS_HOST=172.17.0.1
+export IPFS_API_PORT=5001
+export IPFS_TCP_PORT=4001
+#export IPFS_WS_PORT=5269
+
 npm start

shell-scripts/ipfs-service-provider-generic.sh

@@ -3,7 +3,7 @@
 # This script is an example for running a generic ipfs-service-provider instance.
 
 # Ports
-export PORT=5001 # REST API port
+export PORT=5005 # REST API port
 export IPFS_TCP_PORT=5268
 export IPFS_WS_PORT=5269
 

shell-scripts/local-external-ipfs-node.sh

@@ -0,0 +1,31 @@
+#!/bin/bash
+
+# This script is an example for running a production environment, which is
+# defined by running an external go-ipfs node.
+
+# Ports
+export PORT=5005 # REST API port
+
+# The human-readible name that is used when displaying data about this node.
+export COORD_NAME=trout-dev-bch-wallet-consumer
+
+# This is used for end-to-end encryption (e2ee).
+export MNEMONIC="stomach mean catch march census author cousin size south romance pumpkin trap"
+
+# 0 = less verbose. 3 = most verbose
+export DEBUG_LEVEL=2
+
+# Production settings that use external IPFS node.
+# https://github.com/christroutner/docker-ipfs
+export SVC_ENV=production
+export IPFS_HOST=localhost
+export IPFS_API_PORT=5001
+
+# Configure IPFS ports
+export IPFS_TCP_PORT=4001
+#export IPFS_WS_PORT=5269
+
+# MongoDB connection string.
+export DBURL=mongodb://localhost:27017/ipfs-service-dev
+
+npm start

src/adapters/bch/index.js

@@ -58,18 +58,61 @@ class BchAdapter {
     }
   }
 
+  // Get the status of BCH wallet services this node can talk to. Returns an
+  // array of BCH wallet service providers.
   async getStatus () {
     try {
-      console.log(
-        'this.ipfs.ipfsCoordAdapter.state: ',
-        this.ipfs.ipfsCoordAdapter.state
-      )
+      const peerData = this.ipfs.ipfsCoordAdapter.ipfsCoord.thisNode.peerData
+      // console.log(`peerData: ${JSON.stringify(peerData, null, 2)}`)
 
-      const status = {
-        state: this.ipfs.ipfsCoordAdapter.state
+      // const status = {
+      //   state: this.ipfs.ipfsCoordAdapter.state
+      // }
+
+      // Add names to the IPFS IDs for each provider.
+      const initialServiceProviders =
+        this.ipfs.ipfsCoordAdapter.state.serviceProviders
+      const serviceProviders = []
+      for (let i = 0; i < initialServiceProviders.length; i++) {
+        const thisProvider = initialServiceProviders[i]
+
+        const providerData = peerData.filter((x) => x.from === thisProvider)
+
+        if (providerData.length) {
+          const provObj = {
+            ipfsId: thisProvider,
+            name: providerData[0].data.jsonLd.name
+          }
+
+          serviceProviders.push(provObj)
+        }
       }
 
-      return status
+      // console.log(
+      //   `serviceProviders: ${JSON.stringify(serviceProviders, null, 2)}`
+      // )
+
+      const outObj = {
+        serviceProviders,
+        selectedProvider:
+          this.ipfs.ipfsCoordAdapter.state.selectedServiceProvider
+      }
+      // console.log('outObj: ', outObj)
+
+      return outObj
+    } catch (err) {
+      // console.log('createUser() error: ', err)
+      wlogger.error('Error in use-cases/bch.js/getStatus()')
+      throw err
+    }
+  }
+
+  // Choose the BCH wallet service to use.
+  async selectProvider (providerId) {
+    try {
+      this.ipfs.ipfsCoordAdapter.config.preferredProvider = providerId
+
+      return true
     } catch (err) {
       // console.log('createUser() error: ', err)
       wlogger.error('Error in use-cases/bch.js/getStatus()')

src/adapters/index.js

@@ -17,6 +17,7 @@ const Nodemailer = require('./nodemailer')
 const JSONFiles = require('./json-files')
 const FullStackJWT = require('./fullstack-jwt')
 const BCH = require('./bch')
+const P2WDB = require('./p2wdb')
 
 const config = require('../../config')
 
@@ -41,6 +42,7 @@ class Adapters {
     this.bchjs = new BCHJS()
     this.config = config
     this.bch = new BCH(localConfig)
+    this.p2wdb = new P2WDB(localConfig)
 
     // Get a valid JWT API key and instance bch-js.
     this.fullStackJwt = new FullStackJWT(config)

src/adapters/ipfs/index.js

@@ -58,6 +58,130 @@ class IPFS {
       throw err
     }
   }
+
+  // Get the status of this IPFS node.
+  getStatus () {
+    try {
+      // console.log(
+      //   'this.ipfsCoordAdapter.ipfsCoord.thisNode: ',
+      //   this.ipfsCoordAdapter.ipfsCoord.thisNode
+      // )
+
+      const statusObj = {
+        ipfsId: this.ipfsCoordAdapter.ipfsCoord.thisNode.ipfsId,
+        multiAddrs: this.ipfsCoordAdapter.ipfsCoord.thisNode.ipfsMultiaddrs,
+        bchAddr: this.ipfsCoordAdapter.ipfsCoord.thisNode.bchAddr,
+        slpAddr: this.ipfsCoordAdapter.ipfsCoord.thisNode.slpAddr,
+        pubKey: this.ipfsCoordAdapter.ipfsCoord.thisNode.pubKey,
+        peers: this.ipfsCoordAdapter.ipfsCoord.thisNode.peerList.length,
+        relays: this.ipfsCoordAdapter.ipfsCoord.thisNode.relayData.length
+      }
+
+      return statusObj
+    } catch (err) {
+      console.error('Error in ipfs-coord.js/getStatus()')
+      throw err
+    }
+  }
+
+  // Get details on the other peers this node is connected to.
+  async getPeers (showAll) {
+    try {
+      const peerData = this.ipfsCoordAdapter.ipfsCoord.thisNode.peerData
+      // console.log(`peerData: ${JSON.stringify(peerData, null, 2)}`)
+
+      let ipfsPeers =
+        await this.ipfsCoordAdapter.ipfsCoord.adapters.ipfs.getPeers()
+      // console.log('ipfsPeers: ', ipfsPeers)
+
+      ipfsPeers = this._removeDuplicatePeers(ipfsPeers)
+      // console.log('filtered ipfsPeers: ', ipfsPeers)
+
+      // Loop through each IPFS peer and hydrate it with data from the peerData.
+      for (let i = 0; i < ipfsPeers.length; i++) {
+        const thisPeer = ipfsPeers[i]
+
+        if (!showAll) {
+          // Delete properties that don't contain good info.
+          delete thisPeer.muxer
+          delete thisPeer.latency
+          delete thisPeer.streams
+        }
+
+        // Get the ipfs-coord peer data for this peer.
+        let thisPeerData = peerData.filter((x) =>
+          x.from.includes(thisPeer.peer)
+        )
+        thisPeerData = thisPeerData[0]
+
+        // Skip if peerData for this IPFS peer could not be found.
+        if (!thisPeerData) continue
+
+        try {
+          // console.log('thisPeerData: ', thisPeerData)
+
+          // Add data to the IPFS peer data.
+          thisPeer.name = thisPeerData.data.jsonLd.name
+          thisPeer.protocol = thisPeerData.data.jsonLd.protocol
+          thisPeer.version = thisPeerData.data.jsonLd.version
+
+          if (showAll) {
+            // Add all the peer data.
+            thisPeer.peerData = thisPeerData
+          }
+        } catch (err) {
+          console.log(
+            `Error trying to hydrate peer ${thisPeer.peer}: ${err.message}`
+          )
+        }
+      }
+
+      return ipfsPeers
+    } catch (err) {
+      console.error('Error in getPeers(): ', err)
+      throw err
+    }
+  }
+
+  // Get data about the known Circuit Relays. Hydrate with data from peers list.
+  getRelays () {
+    try {
+      const relayData = this.ipfsCoordAdapter.ipfsCoord.thisNode.relayData
+      const peerData = this.ipfsCoordAdapter.ipfsCoord.thisNode.peerData
+      // console.log(`relayData: ${JSON.stringify(relayData, null, 2)}`)
+      // console.log(`peerData: ${JSON.stringify(peerData, null, 2)}`)
+
+      for (let i = 0; i < relayData.length; i++) {
+        const thisRelay = relayData[i]
+
+        // Find the peer that corresponds to this relay.
+        const thisPeer = peerData.filter((x) =>
+          x.from.includes(thisRelay.ipfsId)
+        )
+        // console.log('thisPeer: ', thisPeer)
+
+        // If the peer couldn't be found, skip.
+        if (!thisPeer.length) {
+          thisRelay.name = ''
+          continue
+        }
+
+        thisRelay.name = thisPeer[0].data.jsonLd.name
+      }
+
+      return relayData
+    } catch (err) {
+      console.error('Error in getRelays(): ', err)
+      throw err
+    }
+  }
+
+  // Expects an array of peers and returns an array of peers with duplicates
+  // removed.
+  _removeDuplicatePeers (arr) {
+    // https://stackoverflow.com/questions/2218999/how-to-remove-all-duplicates-from-an-array-of-objects
+    return arr.filter((v, i, a) => a.findIndex((t) => t.peer === v.peer) === i)
+  }
 }
 
 module.exports = IPFS

src/adapters/ipfs/ipfs-coord.js

@@ -15,8 +15,10 @@ const config = require('../../../config')
 // const JSONRPC = require('../../controllers/json-rpc/')
 
 // The minimum version of ipfs-bch-wallet-service that this wallet can work with.
-const MIN_BCH_WALLET_VERSION = '1.11.0'
+const MIN_BCH_WALLET_VERSION = '1.11.11'
 const WALLET_PROTOCOL = 'bch-wallet'
+const MIN_P2WDB_VERSION = '1.4.0'
+const P2WDB_PROTOCOL = 'p2wdb'
 
 let _this
 
@@ -48,12 +50,18 @@ class IpfsCoordAdapter {
     this.isReady = false
 
     // Periodically poll services for available wallet service providers.
-    this.pollServiceInterval = setInterval(this.pollForServices, 10000)
+    this.pollBchServiceInterval = setInterval(this.pollForBchServices, 10000)
+    this.pollP2wdbServiceInterval = setInterval(
+      this.pollForP2wdbServices,
+      11000
+    )
 
     // State object. TODO: Make this more robust.
     this.state = {
       serviceProviders: [],
-      selectedServiceProvider: ''
+      selectedServiceProvider: '',
+      p2wdbProviders: [],
+      selectedP2wdbProvider: ''
     }
 
     _this = this
@@ -70,6 +78,7 @@ class IpfsCoordAdapter {
 
         circuitRelayInfo.ip4 = ip4
         circuitRelayInfo.tcpPort = this.config.ipfsTcpPort
+        circuitRelayInfo.wsPort = this.config.ipfsWsPort
 
         // Domain used by browser-based secure websocket connections.
         circuitRelayInfo.crDomain = this.config.crDomain
@@ -78,7 +87,7 @@ class IpfsCoordAdapter {
       }
     }
 
-    this.ipfsCoord = new this.IpfsCoord({
+    const ipfsCoordOptions = {
       ipfs: this.ipfs,
       type: 'node.js',
       // type: 'browser',
@@ -89,7 +98,14 @@ class IpfsCoordAdapter {
       apiInfo: this.config.apiInfo,
       announceJsonLd: this.config.announceJsonLd,
       debugLevel: this.config.debugLevel
-    })
+    }
+
+    // Production env uses external go-ipfs node.
+    if (this.config.isProduction) {
+      ipfsCoordOptions.nodeType = 'external'
+    }
+
+    this.ipfsCoord = new this.IpfsCoord(ipfsCoordOptions)
 
     // Wait for the ipfs-coord library to signal that it is ready.
     await this.ipfsCoord.start()
@@ -112,9 +128,91 @@ class IpfsCoordAdapter {
     }
   }
 
-  // Poll the ipfs-coord coordination channel for available service providers.
-  // This method is called periodically by a timer-interval.
-  pollForServices () {
+  // Poll the ipfs-coord coordination channel for available P2WDB service
+  // providers. This method is called periodically by a timer-interval.
+  pollForP2wdbServices () {
+    try {
+      // An array of IPFS IDs of other nodes in the coordination pubsub channel.
+      const peers = _this.ipfsCoord.thisNode.peerList
+      // console.log(`peers: ${JSON.stringify(peers, null, 2)}`)
+
+      // Array of objects. Each object is the IPFS ID of the peer and contains
+      // data about that peer.
+      const peerData = _this.ipfsCoord.thisNode.peerData
+      // console.log(`peerData: ${JSON.stringify(peerData, null, 2)}`)
+
+      for (let i = 0; i < peers.length; i++) {
+        const thisPeer = peers[i]
+        const thisData = peerData.filter((x) => x.from === thisPeer)
+        const thisPeerData = thisData[0]
+
+        // Create a 'fingerprint' that defines the wallet service.
+        const protocol = thisPeerData.data.jsonLd.protocol
+        const version = thisPeerData.data.jsonLd.version
+        // console.log(
+        //   `debug: peer ${thisPeer} uses protocol: ${protocol} v${version}`
+        // )
+
+        let versionMatches = false
+        if (version) {
+          versionMatches = _this.semver.gt(version, MIN_P2WDB_VERSION)
+        }
+
+        // p2wdbProviders: [],
+        // selectedP2wdbProvider: ''
+
+        // Ignore any peers that don't match the fingerprint for a BCH wallet
+        // service.
+        if (protocol && protocol.includes(P2WDB_PROTOCOL) && versionMatches) {
+          // console.log('Matching peer: ', thisPeerData)
+
+          // Temporary business logic.
+          // Use the first available wallet service detected.
+          if (_this.state.p2wdbProviders.length === 0) {
+            _this.state.selectedP2wdbProvider = thisPeer
+
+            // Persist the config setting, so it can be used by other commands.
+            // _this.conf.set('selectedService', thisPeer)
+            console.log(`---->P2WDB service selected: ${thisPeer}`)
+          }
+
+          // If a preferred provider is set in the config file, then connect
+          // to the preferred provider when it's discovered.
+          if (
+            _this.config.preferredP2wdbProvider &&
+            thisPeer === _this.config.preferredP2wdbProvider
+          ) {
+            _this.state.selectedP2wdbProvider = thisPeer
+          }
+
+          // Check if the peer has already been added to the list of providers.
+          const alreadyExists = _this.state.p2wdbProviders.filter(
+            (x) => x === thisPeer
+          )
+
+          // Add the peer to the list of serviceProviders if it doesn't already
+          // exist in the list.
+          if (!alreadyExists.length) {
+            _this.state.p2wdbProviders.push(thisPeer)
+          }
+        }
+      }
+    } catch (err) {
+      // catch and handle known failure mode.
+      if (
+        err.message.includes("Cannot read property 'peerList' of undefined")
+      ) {
+        return
+      }
+
+      console.error('Error in pollForP2wdbServices()')
+      // Do not throw error. This is a top-level function.
+    }
+  }
+
+  // Poll the ipfs-coord coordination channel for available BCH wallet service
+  // providers. This method is called periodically by a timer-interval.
+  pollForBchServices () {
     try {
       // An array of IPFS IDs of other nodes in the coordination pubsub channel.
       const peers = _this.ipfsCoord.thisNode.peerList
@@ -179,7 +277,14 @@ class IpfsCoordAdapter {
         }
       }
     } catch (err) {
-      console.error('Error in pollForServices(): ', err)
+      // catch and handle known failure mode.
+      if (
+        err.message.includes("Cannot read property 'peerList' of undefined")
+      ) {
+        return
+      }
+
+      console.error('Error in pollForBchServices(): ', err)
       // Do not throw error. This is a top-level function.
     }
   }
@@ -198,14 +303,4 @@ class IpfsCoordAdapter {
   }
 }
 
-// Create a random number to use in the name of this IPFS n ode.
-// const randNum = Math.floor(Math.random() * 10000)
-
-// const announceJsonLd = {
-//   '@context': 'https://schema.org/',
-//   '@type': 'Person',
-//   name: `wallet-consumer-${randNum}`,
-//   description: 'A consumer of BCH wallet services'
-// }
-
 module.exports = IpfsCoordAdapter

src/adapters/ipfs/ipfs.js

@@ -10,27 +10,40 @@
 
 // Global npm libraries
 // const IPFS = require('ipfs')
-const IPFS = require('@chris.troutner/ipfs')
+// const IPFS = require('@chris.troutner/ipfs')
+const IPFSembedded = require('ipfs')
+const IPFSexternal = require('ipfs-http-client')
+const fs = require('fs')
+const http = require('http')
 
 // Local libraries
 const config = require('../../../config')
 
+const IPFS_DIR = './.ipfsdata/ipfs'
+
 class IpfsAdapter {
   constructor (localConfig) {
     // Encapsulate dependencies
-    this.IPFS = IPFS
+    this.config = config
+
+    // Choose the IPFS constructor based on the config settings.
+    this.IPFS = IPFSembedded // default
+    if (this.config.isProduction) {
+      this.IPFS = IPFSexternal
+    }
 
     // Properties of this class instance.
     this.isReady = false
-    this.config = config
+
+    this.fs = fs
   }
 
   // Start an IPFS node.
   async start () {
     try {
       // Ipfs Options
-      const ipfsOptions = {
-        repo: './.ipfsdata/ipfs',
+      const ipfsOptionsEmbedded = {
+        repo: IPFS_DIR,
         start: true,
         config: {
           relay: {
@@ -51,10 +64,26 @@ class IpfsAdapter {
               `/ip4/0.0.0.0/tcp/${this.config.ipfsTcpPort}`,
               `/ip4/0.0.0.0/tcp/${this.config.ipfsWsPort}/ws`
             ]
+          },
+          Datastore: {
+            StorageMax: '2GB',
+            StorageGCWatermark: 50,
+            GCPeriod: '15m'
           }
         }
       }
 
+      const ipfsOptionsExternal = {
+        host: this.config.ipfsHost,
+        port: this.config.ipfsApiPort,
+        agent: http.Agent({ keepAlive: true, maxSockets: 2000 })
+      }
+
+      let ipfsOptions = ipfsOptionsEmbedded
+      if (this.config.isProduction) {
+        ipfsOptions = ipfsOptionsExternal
+      }
+
       // Create a new IPFS node.
       this.ipfs = await this.IPFS.create(ipfsOptions)
 
@@ -71,6 +100,12 @@ class IpfsAdapter {
       return this.ipfs
     } catch (err) {
       console.error('Error in ipfs.js/start()')
+
+      // If IPFS crashes because the /blocks directory is full, wipe the directory.
+      if (err.message.includes('No space left on device')) {
+        this.rmBlocksDir()
+      }
+
       throw err
     }
   }
@@ -80,6 +115,26 @@ class IpfsAdapter {
 
     return true
   }
+
+  // Remove the '/blocks' directory that is used to store IPFS data.
+  // Dev Note: It's assumed this node is not pinning any data and that
+  // everything in this directory is transient. This folder will regularly
+  // fill up and prevent IPFS from starting.
+  rmBlocksDir () {
+    try {
+      const dir = `${IPFS_DIR}/blocks`
+      console.log(`Deleting ${dir} directory...`)
+
+      this.fs.rmdirSync(dir, { recursive: true })
+
+      console.log(`${dir} directory is deleted!`)
+
+      return true // Signal successful execution.
+    } catch (err) {
+      console.log('Error in rmBlocksDir()')
+      throw err
+    }
+  }
 }
 
 module.exports = IpfsAdapter

src/adapters/p2wdb/index.js

@@ -0,0 +1,268 @@
+/*
+  This library contains business-logic for dealing with P2WDB service
+  providers. Most of these functions are called by the /p2wdb REST API endpoints.
+*/
+
+// Public npm libraries
+const { v4: uid } = require('uuid')
+const jsonrpc = require('jsonrpc-lite')
+
+// Local libraries
+const { wlogger } = require('../wlogger')
+
+let _this
+
+class P2wdbAdapter {
+  constructor (localConfig = {}) {
+    // console.log('BCH localConfig: ', localConfig)
+    this.ipfs = localConfig.ipfs
+    if (!this.ipfs) {
+      throw new Error(
+        'An instance of IPFS must be passed when instantiating the P2WDB Adapter library.'
+      )
+    }
+    this.eventEmitter = localConfig.eventEmitter
+    if (!this.eventEmitter) {
+      throw new Error(
+        'An instance of an EventEmitter must be passed when instantiating the adapters.'
+      )
+    }
+
+    // Connect the RPC handler when the event fires with new data.
+    this.eventEmitter.on('rpcData', this.rpcHandler)
+
+    // Encapsulate dependencies
+    this.uid = uid
+    this.jsonrpc = jsonrpc
+
+    // A queue for holding RPC data that has arrived.
+    this.rpcDataQueue = []
+
+    _this = this // Global handle on instance of this Class.
+  }
+
+  // This handler is triggered when RPC data comes in over IPFS.
+  // Handle RPC input, and add the response to the RPC queue.
+  // Once in the queue, it will get processed by waitForRPCResponse()
+  rpcHandler (data) {
+    try {
+      // Convert string input into an object.
+      // const jsonData = JSON.parse(data)
+
+      console.log(`JSON RPC response for ID ${data.payload.id} received.`)
+
+      _this.rpcDataQueue.push(data)
+    } catch (err) {
+      console.error('Error in p2wdb/rpcHandler(): ', err)
+      // Do not throw error. This is a top-level function.
+    }
+  }
+
+  // Get the status of BCH wallet services this node can talk to. Returns an
+  // array of BCH wallet service providers.
+  async getStatus () {
+    try {
+      const peerData = this.ipfs.ipfsCoordAdapter.ipfsCoord.thisNode.peerData
+      // console.log(`peerData: ${JSON.stringify(peerData, null, 2)}`)
+
+      // const status = {
+      //   state: this.ipfs.ipfsCoordAdapter.state
+      // }
+
+      // Add names to the IPFS IDs for each provider.
+      const initialServiceProviders =
+        this.ipfs.ipfsCoordAdapter.state.p2wdbProviders
+      const serviceProviders = []
+      for (let i = 0; i < initialServiceProviders.length; i++) {
+        const thisProvider = initialServiceProviders[i]
+
+        const providerData = peerData.filter((x) => x.from === thisProvider)
+
+        if (providerData.length) {
+          const provObj = {
+            ipfsId: thisProvider,
+            name: providerData[0].data.jsonLd.name
+          }
+
+          serviceProviders.push(provObj)
+        }
+      }
+
+      // console.log(
+      //   `serviceProviders: ${JSON.stringify(serviceProviders, null, 2)}`
+      // )
+
+      const outObj = {
+        serviceProviders,
+        selectedProvider:
+          this.ipfs.ipfsCoordAdapter.state.selectedP2wdbProvider
+      }
+      // console.log('outObj: ', outObj)
+
+      return outObj
+    } catch (err) {
+      // console.log('createUser() error: ', err)
+      wlogger.error('Error in adapters/p2wdb.js/getStatus()')
+      throw err
+    }
+  }
+
+  // Choose the BCH wallet service to use.
+  async selectProvider (providerId) {
+    try {
+      this.ipfs.ipfsCoordAdapter.config.preferredP2wdbProvider = providerId
+
+      return true
+    } catch (err) {
+      // console.log('createUser() error: ', err)
+      wlogger.error('Error in adapters/p2wdb/getStatus()')
+      throw err
+    }
+  }
+
+  // Read an entry from the P2WDB, given an entry hash.
+  async getEntryByHash (hash) {
+    try {
+      // Input validation.
+      if (!hash || typeof hash !== 'string') {
+        throw new Error('getEntry() input hash must be a string.')
+      }
+
+      // Throw an error if this IPFS node has not yet made a connection to a
+      // wallet service provider.
+      const selectedProvider =
+        this.ipfs.ipfsCoordAdapter.state.selectedP2wdbProvider
+      if (!selectedProvider) {
+        throw new Error('No P2WDB Service provider available yet.')
+      }
+
+      const rpcData = {
+        endpoint: 'getByHash',
+        hash
+      }
+
+      // Generate a UUID for the call.
+      const rpcId = this.uid()
+
+      // Generate a JSON RPC command.
+      const cmd = this.jsonrpc.request(rpcId, 'p2wdb', rpcData)
+      const cmdStr = JSON.stringify(cmd)
+      // console.log('cmdStr: ', cmdStr)
+
+      // Send the RPC command to selected wallet service.
+      const thisNode = this.ipfs.ipfsCoordAdapter.ipfsCoord.thisNode
+      await this.ipfs.ipfsCoordAdapter.ipfsCoord.useCases.peer.sendPrivateMessage(
+        selectedProvider,
+        cmdStr,
+        thisNode
+      )
+
+      // Wait for data to come back from the wallet service.
+      const data = await this.waitForRPCResponse(rpcId)
+
+      return data
+    } catch (err) {
+      console.error('Error in getEntryByHash()')
+      throw err
+    }
+  }
+
+  async writeEntry (writeObj) {
+    try {
+      const { txid, signature, message, data } = writeObj
+
+      // Throw an error if this IPFS node has not yet made a connection to a
+      // wallet service provider.
+      const selectedProvider =
+        this.ipfs.ipfsCoordAdapter.state.selectedP2wdbProvider
+      if (!selectedProvider) {
+        throw new Error('No P2WDB Service provider available yet.')
+      }
+
+      const rpcData = {
+        endpoint: 'write',
+        txid,
+        signature,
+        message,
+        data
+      }
+
+      // Generate a UUID for the call.
+      const rpcId = this.uid()
+
+      // Generate a JSON RPC command.
+      const cmd = this.jsonrpc.request(rpcId, 'p2wdb', rpcData)
+      const cmdStr = JSON.stringify(cmd)
+      // console.log('cmdStr: ', cmdStr)
+
+      // Send the RPC command to selected wallet service.
+      const thisNode = this.ipfs.ipfsCoordAdapter.ipfsCoord.thisNode
+      await this.ipfs.ipfsCoordAdapter.ipfsCoord.useCases.peer.sendPrivateMessage(
+        selectedProvider,
+        cmdStr,
+        thisNode
+      )
+
+      // Wait for data to come back from the wallet service.
+      const result = await this.waitForRPCResponse(rpcId)
+
+      return result
+    } catch (err) {
+      console.error('Error in adapters/p2wdb/writeEntry()')
+      throw err
+    }
+  }
+
+  // Returns a promise that resolves to data when the RPC response is recieved.
+  async waitForRPCResponse (rpcId) {
+    try {
+      // Initialize variables for tracking the return data.
+      let dataFound = false
+      let cnt = 0
+
+      // Default return value, if the remote computer does not respond in time.
+      let data = {
+        success: false,
+        message: 'request timed out',
+        data: ''
+      }
+
+      // Loop that waits for a response from the service provider.
+      do {
+        // console.log(`this.rpcDataQueue.length: ${this.rpcDataQueue.length}`)
+        for (let i = 0; i < this.rpcDataQueue.length; i++) {
+          const rawData = this.rpcDataQueue[i]
+          // console.log(`rawData: ${JSON.stringify(rawData, null, 2)}`)
+
+          if (rawData.payload.id === rpcId) {
+            dataFound = true
+            // console.log('data was found in the queue')
+
+            data = rawData.payload.result.value
+
+            // Remove the data from the queue
+            this.rpcDataQueue.splice(i, 1)
+
+            break
+          }
+        }
+
+        // Wait between loops.
+        // await this.sleep(1000)
+        await this.ipfs.ipfsCoordAdapter.bchjs.Util.sleep(2000)
+
+        cnt++
+
+        // Exit if data was returned, or the window for a response expires.
+      } while (!dataFound && cnt < 10)
+      // console.log(`dataFound: ${dataFound}, cnt: ${cnt}`)
+
+      return data
+    } catch (err) {
+      console.error('Error in waitForRPCResponse()')
+      throw err
+    }
+  }
+}
+
+module.exports = P2wdbAdapter

src/controllers/index.js

@@ -7,21 +7,18 @@
 // Public npm libraries.
 const EventEmitter = require('events')
 
-// Load the Clean Architecture Adapters library
+// Local libraries
+const config = require('../../config')
 const Adapters = require('../adapters')
-
-// Load the JSON RPC Controller.
 const JSONRPC = require('./json-rpc')
-
-// Load the Clean Architecture Use Case libraries.
 const UseCases = require('../use-cases')
-// const useCases = new UseCases({ adapters })
-
-// Load the REST API Controllers.
 const RESTControllers = require('./rest-api')
 
 class Controllers {
   constructor (localConfig = {}) {
+    // Encapsulate dependencies
+    this.config = config
+
     // Initialize EventEmitters used to pass event-driven data around the app.
     this.eventEmitter = new EventEmitter()
     localConfig.eventEmitter = this.eventEmitter
@@ -33,13 +30,16 @@ class Controllers {
   }
 
   async attachControllers (app) {
-    // Wait for any startup processes to complete for the Adapters libraries.
-    await this.adapters.start()
+    // Skip in a test environment.
+    if (this.config.env !== 'test') {
+      // Wait for any startup processes to complete for the Adapters libraries.
+      await this.adapters.start()
 
-    // Attach the REST controllers to the Koa app.
-    // this.attachRESTControllers(app)
+      // Attach the REST controllers to the Koa app.
+      // this.attachRESTControllers(app)
 
-    this.attachRPCControllers()
+      this.attachRPCControllers()
+    }
   }
 
   // Top-level function for this library.

src/controllers/rest-api/bch/controller.js

@@ -1,5 +1,5 @@
 /*
-  REST API Controller library for the /user route
+  REST API Controller library for the /bch route
 */
 
 const { wlogger } = require('../../../adapters/wlogger')
@@ -51,6 +51,35 @@ class BchRESTControllerLib {
     }
   }
 
+  /**
+   * @api {post} /bch/provider Provider
+   * @apiPermission public
+   * @apiName Provider
+   * @apiGroup REST BCH
+   * @apiDescription Select a different BCH wallet service on the IPFS network,
+   * for interacting with the BCH blockchain.
+   *
+   * @apiExample Example usage:
+   * curl -H "Content-Type: application/json" -X POST -d '{ "provider": "QmXtHADckCmT6jodpAgn3TcDQWjC29gQd2fKKHDTpo8DJT" }' localhost:5001/bch/provider
+   */
+  async postProvider (ctx) {
+    try {
+      const providerId = ctx.request.body.provider
+
+      await this.adapters.bch.selectProvider(providerId)
+
+      const body = {
+        success: true
+      }
+
+      ctx.body = body
+    } catch (err) {
+      wlogger.error('Error in bch/controller.js/postProvider(): ')
+      // ctx.throw(422, err.message)
+      this.handleError(ctx, err)
+    }
+  }
+
   /**
    * @api {post} /bch/balance Balance
    * @apiName Balance
@@ -196,7 +225,7 @@ class BchRESTControllerLib {
       const utxos = await this.adapters.bch.getUtxos(address)
       // console.log(`utxos: ${JSON.stringify(utxos, null, 2)}`)
 
-      ctx.body = utxos
+      ctx.body = [utxos]
     } catch (err) {
       this.handleError(ctx, err)
     }
@@ -402,10 +431,10 @@ class BchRESTControllerLib {
   }
 
   /**
-   * @api {JSON} /bch PubKey
+   * @api {REST} /bch/pubkey PubKey
    * @apiPermission public
    * @apiName PubKey
-   * @apiGroup JSON BCH
+   * @apiGroup REST BCH
    * @apiDescription Get the public key from an address.
    * Given an address the endpoint will return an object with the
    * following properties
@@ -417,7 +446,7 @@ class BchRESTControllerLib {
    *      - publickey: - Address public key
    *
    * @apiExample Example usage:
-   * {"jsonrpc":"2.0","id":"555","method":"bch","params":{ "endpoint": "pubkey", "address": "bitcoincash:qpnty9t0w93fez04h7yzevujpv8pun204qv6yfuahk"}}
+   * curl -H "Content-Type: application/json" -X POST -d '{ "txid": "01517ff1587fa5ffe6f5eb91c99cf3f2d22330cd7ee847e928ce90ca95bf781b" }' localhost:5001/bch/pubkey
    *
    * @apiSuccessExample {json} Success-Response:
    *  {
@@ -434,7 +463,6 @@ class BchRESTControllerLib {
    *            "success": true,
    *            "publicKey": "033f267fec0f7eb2b27f8c2e3052b3d03b09d36b47de4082ffb638ffb334ef0eee"
    *     }
-   *
    *  }
    */
   async pubKey (ctx) {
@@ -442,7 +470,7 @@ class BchRESTControllerLib {
       const address = ctx.request.body.address
 
       const data = await this.adapters.bch.getPubKey(address)
-      // console.log(`utxos: ${JSON.stringify(utxos, null, 2)}`)
+      console.log(`pubkey data: ${JSON.stringify(data, null, 2)}`)
 
       ctx.body = data
     } catch (err) {

src/controllers/rest-api/bch/index.js

@@ -52,6 +52,7 @@ class BchRouter {
 
     // Define the routes and attach the controller.
     this.router.get('/', this.getStatus)
+    this.router.post('/provider', this.postProvider)
     this.router.post('/balance', this.postBalance)
     this.router.post('/utxos', this.postUtxos)
     this.router.post('/broadcast', this.postBroadcast)
@@ -68,6 +69,10 @@ class BchRouter {
     await _this.bchRESTController.getStatus(ctx, next)
   }
 
+  async postProvider (ctx, next) {
+    await _this.bchRESTController.postProvider(ctx, next)
+  }
+
   async postBalance (ctx, next) {
     await _this.bchRESTController.balance(ctx, next)
   }

src/controllers/rest-api/index.js

@@ -12,6 +12,8 @@ const UserRouter = require('./users')
 const ContactRESTController = require('./contact')
 const LogsRESTController = require('./logs')
 const BchRESTController = require('./bch')
+const IpfsRESTController = require('./ipfs')
+const P2wdbRESTController = require('./p2wdb')
 
 class RESTControllers {
   constructor (localConfig = {}) {
@@ -57,6 +59,14 @@ class RESTControllers {
     // Attach the REST API Controllers associated with the /bch route
     const bchRESTController = new BchRESTController(dependencies)
     bchRESTController.attach(app)
+
+    // Attach the REST API Controllers associated with the /ipfs route
+    const ipfsRESTController = new IpfsRESTController(dependencies)
+    ipfsRESTController.attach(app)
+
+    // Attach the REST API Controllers associated with the /p2wdb route
+    const p2wdbRESTController = new P2wdbRESTController(dependencies)
+    p2wdbRESTController.attach(app)
   }
 }
 

src/controllers/rest-api/ipfs/controller.js

@@ -0,0 +1,98 @@
+/*
+  REST API Controller library for the /ipfs route
+*/
+
+const { wlogger } = require('../../../adapters/wlogger')
+
+let _this
+
+class IpfsRESTControllerLib {
+  constructor (localConfig = {}) {
+    // Dependency Injection.
+    this.adapters = localConfig.adapters
+    if (!this.adapters) {
+      throw new Error(
+        'Instance of Adapters library required when instantiating /ipfs REST Controller.'
+      )
+    }
+    this.useCases = localConfig.useCases
+    if (!this.useCases) {
+      throw new Error(
+        'Instance of Use Cases library required when instantiating /ipfs REST Controller.'
+      )
+    }
+
+    // Encapsulate dependencies
+    // this.UserModel = this.adapters.localdb.Users
+    // this.userUseCases = this.useCases.user
+
+    _this = this
+  }
+
+  /**
+   * @api {get} /ipfs Get status on IPFS infrastructure
+   * @apiPermission public
+   * @apiName GetIpfsStatus
+   * @apiGroup REST BCH
+   *
+   * @apiExample Example usage:
+   * curl -H "Content-Type: application/json" -X GET localhost:5001/ipfs
+   *
+   */
+  async getStatus (ctx) {
+    try {
+      const status = await _this.adapters.ipfs.getStatus()
+
+      ctx.body = { status }
+    } catch (err) {
+      wlogger.error('Error in ipfs/controller.js/getStatus(): ')
+      // ctx.throw(422, err.message)
+      _this.handleError(ctx, err)
+    }
+  }
+
+  // Return information on IPFS peers this node is connected to.
+  async getPeers (ctx) {
+    try {
+      const showAll = ctx.request.body.showAll
+
+      const peers = await _this.adapters.ipfs.getPeers(showAll)
+
+      ctx.body = { peers }
+    } catch (err) {
+      wlogger.error('Error in ipfs/controller.js/getPeers(): ')
+      // ctx.throw(422, err.message)
+      _this.handleError(ctx, err)
+    }
+  }
+
+  // Get data about the known Circuit Relays. Hydrate with data from peers list.
+  async getRelays (ctx) {
+    try {
+      const relays = await _this.adapters.ipfs.getRelays()
+
+      ctx.body = { relays }
+    } catch (err) {
+      wlogger.error('Error in ipfs/controller.js/getRelays(): ')
+      // ctx.throw(422, err.message)
+      _this.handleError(ctx, err)
+    }
+  }
+
+  // DRY error handler
+  handleError (ctx, err) {
+    // If an HTTP status is specified by the buisiness logic, use that.
+    if (err.status) {
+      if (err.message) {
+        ctx.throw(err.status, err.message)
+      } else {
+        ctx.throw(err.status)
+      }
+    } else {
+      // By default use a 422 error if the HTTP status is not specified.
+      ctx.throw(422, err.message)
+    }
+  }
+}
+
+module.exports = IpfsRESTControllerLib

src/controllers/rest-api/ipfs/index.js

@@ -0,0 +1,68 @@
+/*
+  REST API library for the /ipfs route.
+*/
+
+// Public npm libraries.
+const Router = require('koa-router')
+
+// Local libraries.
+const IPFSRESTControllerLib = require('./controller')
+const Validators = require('../middleware/validators')
+
+// let _this
+
+class BchRouter {
+  constructor (localConfig = {}) {
+    // Dependency Injection.
+    this.adapters = localConfig.adapters
+    if (!this.adapters) {
+      throw new Error(
+        'Instance of Adapters library required when instantiating IPFS REST Controller.'
+      )
+    }
+    this.useCases = localConfig.useCases
+    if (!this.useCases) {
+      throw new Error(
+        'Instance of Use Cases library required when instantiating IPFS REST Controller.'
+      )
+    }
+
+    const dependencies = {
+      adapters: this.adapters,
+      useCases: this.useCases
+    }
+
+    // Encapsulate dependencies.
+    this.ipfsRESTController = new IPFSRESTControllerLib(dependencies)
+    this.validators = new Validators()
+
+    // Instantiate the router and set the base route.
+    const baseUrl = '/ipfs'
+    this.router = new Router({ prefix: baseUrl })
+
+    // _this = this
+  }
+
+  attach (app) {
+    if (!app) {
+      throw new Error(
+        'Must pass app object when attaching REST API controllers.'
+      )
+    }
+
+    // Define the routes and attach the controller.
+    this.router.get('/', this.ipfsRESTController.getStatus)
+    this.router.post('/peers', this.ipfsRESTController.getPeers)
+    this.router.post('/relays', this.ipfsRESTController.getRelays)
+
+    // Attach the Controller routes to the Koa app.
+    app.use(this.router.routes())
+    app.use(this.router.allowedMethods())
+  }
+
+  // async getStatus (ctx, next) {
+  //   await _this.ipfsRESTController.getStatus(ctx, next)
+  // }
+}
+
+module.exports = BchRouter

src/controllers/rest-api/p2wdb/controller.js

@@ -0,0 +1,138 @@
+/*
+  REST API Controller library for the /p2wdb route
+*/
+
+const { wlogger } = require('../../../adapters/wlogger')
+
+// let _this
+
+class P2wdbRESTControllerLib {
+  constructor (localConfig = {}) {
+    // Dependency Injection.
+    this.adapters = localConfig.adapters
+    if (!this.adapters) {
+      throw new Error(
+        'Instance of Adapters library required when instantiating /p2wdb REST Controller.'
+      )
+    }
+    this.useCases = localConfig.useCases
+    if (!this.useCases) {
+      throw new Error(
+        'Instance of Use Cases library required when instantiating /p2wdb REST Controller.'
+      )
+    }
+
+    // Encapsulate dependencies
+    // this.UserModel = this.adapters.localdb.Users
+    // this.userUseCases = this.useCases.user
+
+    // _this = this
+  }
+
+  /**
+   * @api {get} /p2wdb Get status on P2WDB infrastructure
+   * @apiPermission public
+   * @apiName GetP2wdbStatus
+   * @apiGroup REST BCH
+   *
+   * @apiExample Example usage:
+   * curl -H "Content-Type: application/json" -X GET localhost:5001/p2wdb
+   *
+   */
+  async getStatus (ctx) {
+    try {
+      const status = await this.adapters.p2wdb.getStatus()
+
+      ctx.body = { status }
+    } catch (err) {
+      wlogger.error('Error in bch/controller.js/getStatus(): ')
+      // ctx.throw(422, err.message)
+      this.handleError(ctx, err)
+    }
+  }
+
+  /**
+   * @api {post} /p2wdb/provider Provider
+   * @apiName Provider
+   * @apiGroup REST P2WDB
+   * @apiDescription Select a different P2WDB service on the IPFS network, for
+   * interacting with the P2WDB.
+   *
+   * @apiExample Example usage:
+   * curl -H "Content-Type: application/json" -X POST -d '{ "provider": "QmXtHADckCmT6jodpAgn3TcDQWjC29gQd2fKKHDTpo8DJT" }' localhost:5001/p2wdb/provider
+   */
+  async postProvider (ctx) {
+    try {
+      const providerId = ctx.request.body.provider
+
+      await this.adapters.p2wdb.selectProvider(providerId)
+
+      const body = {
+        success: true
+      }
+
+      ctx.body = body
+    } catch (err) {
+      wlogger.error('Error in p2wdb/controller.js/postProvider(): ', err)
+      // ctx.throw(422, err.message)
+      this.handleError(ctx, err)
+    }
+  }
+
+  // curl -H "Content-Type: application/json" -X POST -d '{ "hash": "zdpuAzNVEHYegiazAmbnQtvQpEvJGsdXDbcH7vHFYx4NWDUqk" }' localhost:5001/p2wdb/entryFromHash
+  async getEntryByHash (ctx) {
+    try {
+      const hash = ctx.request.body.hash
+
+      const data = await this.adapters.p2wdb.getEntryByHash(hash)
+
+      const body = {
+        success: true,
+        data
+      }
+
+      ctx.body = body
+    } catch (err) {
+      wlogger.error('Error in p2wdb/controller.js/getEntryByHash(): ', err)
+      // ctx.throw(422, err.message)
+      this.handleError(ctx, err)
+    }
+  }
+
+  async writeEntry (ctx) {
+    try {
+      const txid = ctx.request.body.txid
+      const signature = ctx.request.body.signature
+      const message = ctx.request.body.message
+      const data = ctx.request.body.data
+      const writeObj = { txid, signature, message, data }
+
+      const hash = await this.adapters.p2wdb.writeEntry(writeObj)
+
+      ctx.body = {
+        success: true,
+        hash
+      }
+    } catch (err) {
+      wlogger.error('Error in p2wdb/controller.js/writeEntry(): ', err)
+      this.handleError(ctx, err)
+    }
+  }
+
+  // DRY error handler
+  handleError (ctx, err) {
+    // If an HTTP status is specified by the buisiness logic, use that.
+    if (err.status) {
+      if (err.message) {
+        ctx.throw(err.status, err.message)
+      } else {
+        ctx.throw(err.status)
+      }
+    } else {
+      // By default use a 422 error if the HTTP status is not specified.
+      ctx.throw(422, err.message)
+    }
+  }
+}
+
+module.exports = P2wdbRESTControllerLib

src/controllers/rest-api/p2wdb/index.js

@@ -0,0 +1,101 @@
+/*
+  REST API library for /p2wdb route.
+*/
+
+// Public npm libraries.
+const Router = require('koa-router')
+
+// Local libraries.
+const P2wdbRESTControllerLib = require('./controller')
+const Validators = require('../middleware/validators')
+
+let _this
+
+class P2wdbRouter {
+  constructor (localConfig = {}) {
+    // Dependency Injection.
+    this.adapters = localConfig.adapters
+    if (!this.adapters) {
+      throw new Error(
+        'Instance of Adapters library required when instantiating P2WDB REST Controller.'
+      )
+    }
+    this.useCases = localConfig.useCases
+    if (!this.useCases) {
+      throw new Error(
+        'Instance of Use Cases library required when instantiating P2WDB REST Controller.'
+      )
+    }
+
+    const dependencies = {
+      adapters: this.adapters,
+      useCases: this.useCases
+    }
+
+    // Encapsulate dependencies.
+    this.p2wdbRESTController = new P2wdbRESTControllerLib(dependencies)
+    this.validators = new Validators()
+
+    // Instantiate the router and set the base route.
+    const baseUrl = '/p2wdb'
+    this.router = new Router({ prefix: baseUrl })
+
+    _this = this
+  }
+
+  attach (app) {
+    if (!app) {
+      throw new Error(
+        'Must pass app object when attaching REST API controllers.'
+      )
+    }
+
+    // Define the routes and attach the controller.
+    this.router.get('/', this.getStatus)
+    this.router.post('/provider', this.postProvider)
+    this.router.post('/entryFromHash', this.entryFromHash)
+    this.router.post('/write', this.write)
+    // this.router.post('/broadcast', this.postBroadcast)
+    // this.router.post('/transactions', this.postTransactions)
+    // this.router.post('/transaction', this.postTransaction)
+    // this.router.post('/pubkey', this.postPubKey)
+
+    // Attach the Controller routes to the Koa app.
+    app.use(this.router.routes())
+    app.use(this.router.allowedMethods())
+  }
+
+  async getStatus (ctx, next) {
+    await _this.p2wdbRESTController.getStatus(ctx, next)
+  }
+
+  async postProvider (ctx, next) {
+    await _this.p2wdbRESTController.postProvider(ctx, next)
+  }
+
+  async entryFromHash (ctx, next) {
+    await _this.p2wdbRESTController.getEntryByHash(ctx, next)
+  }
+
+  async write (ctx, next) {
+    await _this.p2wdbRESTController.writeEntry(ctx, next)
+  }
+
+  // async postBroadcast (ctx, next) {
+  //   await _this.bchRESTController.broadcast(ctx, next)
+  // }
+  //
+  // async postTransactions (ctx, next) {
+  //   await _this.bchRESTController.transactions(ctx, next)
+  // }
+  //
+  // async postTransaction (ctx, next) {
+  //   await _this.bchRESTController.transaction(ctx, next)
+  // }
+  //
+  // async postPubKey (ctx, next) {
+  //   await _this.bchRESTController.pubKey(ctx, next)
+  // }
+}
+
+module.exports = P2wdbRouter

test/e2e/manual/bch-e2e.js

@@ -65,7 +65,7 @@ describe('#BCH E2E Tests', () => {
   describe('#broadcast', () => {
     it('should attempt to broadcast a transaction', async () => {
       const body = {
-        hex: "'01000000013ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a000000006a4730440220540986d1c58d6e76f8f05501c520c38ce55393d0ed7ed3c3a82c69af04221232022058ea43ed6c05fec0eccce749a63332ed4525460105346f11108b9c26df93cd72012103083dfc5a0254613941ddc91af39ff90cd711cdcde03a87b144b883b524660c39ffffffff01807c814a000000001976a914d7e7c4e0b70eaa67ceff9d2823d1bbb9f6df9a5188ac00000000'"
+        hex: '01000000013ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a000000006a4730440220540986d1c58d6e76f8f05501c520c38ce55393d0ed7ed3c3a82c69af04221232022058ea43ed6c05fec0eccce749a63332ed4525460105346f11108b9c26df93cd72012103083dfc5a0254613941ddc91af39ff90cd711cdcde03a87b144b883b524660c39ffffffff01807c814a000000001976a914d7e7c4e0b70eaa67ceff9d2823d1bbb9f6df9a5188ac00000000'
       }
 
       const url = `${SERVER}/bch/broadcast`

test/unit/adapters/ipfs-coord.adapter.unit.js

@@ -29,7 +29,8 @@ describe('#IPFS', () => {
   afterEach(() => {
     sandbox.restore()
 
-    clearInterval(uut.pollServiceInterval)
+    clearInterval(uut.pollBchServiceInterval)
+    clearInterval(uut.pollP2wdbServiceInterval)
   })
 
   describe('#constructor', () => {
@@ -125,7 +126,7 @@ describe('#IPFS', () => {
     })
   })
 
-  describe('#pollForServices', () => {
+  describe('#pollForBchServices', () => {
     it('should find and select the wallet service', () => {
       uut.ipfsCoord = {
         thisNode: {
@@ -134,7 +135,7 @@ describe('#IPFS', () => {
         }
       }
 
-      uut.pollForServices()
+      uut.pollForBchServices()
 
       // It should fine the service in the mocked data.
       assert.equal(
@@ -144,7 +145,7 @@ describe('#IPFS', () => {
     })
 
     it('should catch and report errors', () => {
-      uut.pollForServices()
+      uut.pollForBchServices()
 
       assert.isOk(true, 'Not throwing an error is a success.')
     })

test/unit/adapters/ipfs.adapter.unit.js

@@ -60,4 +60,25 @@ describe('#IPFS-adapter', () => {
       assert.equal(result, true)
     })
   })
+
+  describe('#rmBlocksDir', () => {
+    it('should delete the /blocks directory', () => {
+      const result = uut.rmBlocksDir()
+
+      assert.equal(result, true)
+    })
+
+    it('should catch and throw an error', () => {
+      try {
+        // Force an error
+        sandbox.stub(uut.fs, 'rmdirSync').throws(new Error('test error'))
+
+        uut.rmBlocksDir()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.equal(err.message, 'test error')
+      }
+    })
+  })
 })

test/unit/mocks/adapters/index.js

@@ -12,9 +12,15 @@ const ipfs = {
         peer: {
           sendPrivateMessage: () => {}
         }
+      },
+      thisNode: {
+        peerData: []
       }
     },
-    peerInputHandler: () => {}
+    peerInputHandler: () => {},
+    state: {
+      serviceProviders: []
+    }
   }
 }
 

test/unit/mocks/adapters/ipfs-coord-mocks.js

@@ -46,7 +46,7 @@ const peerData = [
         '@context': 'https://schema.org/',
         '@type': 'WebAPI',
         name: 'trout-bch-wallet-service-dev',
-        version: '1.11.1',
+        version: '1.11.12',
         protocol: 'bch-wallet',
         description:
           'IPFS service providing BCH blockchain access needed by a wallet.',