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

Added broadcast and transaction endpoints

src/controllers/json-rpc/bch/index.js

@@ -0,0 +1,278 @@
+/*
+  This is the JSON RPC router for the Fulcrum API
+*/
+
+// Public npm libraries
+const jsonrpc = require('jsonrpc-lite')
+const BCHJS = require('@psf/bch-js')
+
+// Local libraries
+// const UserLib = require('../../../use-cases/user')
+const Validators = require('../validators')
+const RateLimit = require('../rate-limit')
+
+class BCHRPC {
+  constructor (localConfig = {}) {
+    // Dependency Injection.
+    this.adapters = localConfig.adapters
+    if (!this.adapters) {
+      throw new Error(
+        'Instance of Adapters library required when instantiating BCH JSON RPC Controller.'
+      )
+    }
+    this.useCases = localConfig.useCases
+    if (!this.useCases) {
+      throw new Error(
+        'Instance of Use Cases library required when instantiating BCH JSON RPC Controller.'
+      )
+    }
+
+    // Encapsulate dependencies
+    this.userLib = this.useCases.user
+    this.jsonrpc = jsonrpc
+    this.validators = new Validators(localConfig)
+    this.rateLimit = new RateLimit()
+    this.bchjs = new BCHJS()
+  }
+
+  // Top-level router for this library. All other methods in this class are for
+  // a specific endpoint. This method routes incoming calls to one of those
+  // methods.
+  async bchRouter (rpcData) {
+    let endpoint = 'unknown'
+    try {
+      // console.log('fulcrumRouter rpcData: ', rpcData)
+
+      endpoint = rpcData.payload.params.endpoint
+      // let user
+
+      // Route the call based on the value of the method property.
+      switch (endpoint) {
+        case 'transactions':
+          await this.rateLimit.limiter(rpcData.from)
+          return await this.transactions(rpcData)
+
+        case 'balance':
+          await this.rateLimit.limiter(rpcData.from)
+          return await this.balance(rpcData)
+
+        case 'utxos':
+          await this.rateLimit.limiter(rpcData.from)
+          return await this.utxos(rpcData)
+
+        case 'broadcast':
+          await this.rateLimit.limiter(rpcData.from)
+          return await this.broadcast(rpcData)
+
+        case 'transaction':
+          await this.rateLimit.limiter(rpcData.from)
+          return await this.transaction(rpcData)
+      }
+    } catch (err) {
+      console.error('Error in BCHRPC/rpcRouter()')
+      // throw err
+
+      return {
+        success: false,
+        status: err.status || 500,
+        message: err.message,
+        endpoint
+      }
+    }
+  }
+
+  /**
+   * @api {JSON} /bch Transactions
+   * @apiPermission public
+   * @apiName Transactions
+   * @apiGroup JSON BCH
+   * @apiDescription This endpoint wraps the bchjs.Electrumx.transactions([]) function.
+   *
+   * @apiExample Example usage:
+   * {"jsonrpc":"2.0","id":"555","method":"bch","params":{ "endpoint": "transactions", "addresses": ["bitcoincash:qrl2nlsaayk6ekxn80pq0ks32dya8xfclyktem2mqj"]}}
+   *
+   */
+  async transactions (rpcData) {
+    try {
+      // console.log('createUser rpcData: ', rpcData)
+
+      const addrs = rpcData.payload.params.addresses
+
+      const data = await this.bchjs.Electrumx.transactions(addrs)
+      // console.log(`data: ${JSON.stringify(data, null, 2)}`)
+
+      const retObj = data
+      retObj.status = 200
+
+      return retObj
+    } catch (err) {
+      // console.error('Error in createUser()')
+      // throw err
+
+      // Return an error response
+      return {
+        success: false,
+        status: 422,
+        message: err.message,
+        endpoint: 'transactions'
+      }
+    }
+  }
+
+  /**
+   * @api {JSON} /bch Balance
+   * @apiPermission public
+   * @apiName Balance
+   * @apiGroup JSON BCH
+   * @apiDescription This endpoint wraps the bchjs.Electrumx.balance([]) function.
+   *
+   * @apiExample Example usage:
+   * {"jsonrpc":"2.0","id":"555","method":"bch","params":{ "endpoint": "balance", "addresses": ["bitcoincash:qrl2nlsaayk6ekxn80pq0ks32dya8xfclyktem2mqj"]}}
+   *
+   */
+  async balance (rpcData) {
+    try {
+      // console.log('createUser rpcData: ', rpcData)
+
+      const addrs = rpcData.payload.params.addresses
+
+      const data = await this.bchjs.Electrumx.balance(addrs)
+      // console.log(`data: ${JSON.stringify(data, null, 2)}`)
+
+      const retObj = data
+      retObj.status = 200
+
+      return retObj
+    } catch (err) {
+      // console.error('Error in createUser()')
+      // throw err
+
+      // Return an error response
+      return {
+        success: false,
+        status: 422,
+        message: err.message,
+        endpoint: 'balance'
+      }
+    }
+  }
+
+  /**
+   * @api {JSON} /bch UTXOs
+   * @apiPermission public
+   * @apiName UTXOs
+   * @apiGroup JSON BCH
+   * @apiDescription This endpoint wraps the bchjs.Utxos.get() function. This
+   * endpoint returns UTXOs held at an address, hydrated
+   * with token information.
+   *
+   * @apiExample Example usage:
+   * {"jsonrpc":"2.0","id":"555","method":"bch","params":{ "endpoint": "utxos", "address": "bitcoincash:qrl2nlsaayk6ekxn80pq0ks32dya8xfclyktem2mqj"}}
+   *
+   */
+  async utxos (rpcData) {
+    try {
+      // console.log('createUser rpcData: ', rpcData)
+
+      const addr = rpcData.payload.params.address
+
+      const data = await this.bchjs.Utxo.get(addr)
+      // console.log(`data: ${JSON.stringify(data, null, 2)}`)
+
+      const retObj = data
+      retObj.status = 200
+
+      return retObj
+    } catch (err) {
+      // console.error('Error in createUser()')
+      // throw err
+
+      // Return an error response
+      return {
+        success: false,
+        status: 422,
+        message: err.message,
+        endpoint: 'utxos'
+      }
+    }
+  }
+
+  /**
+   * @api {JSON} /bch Broadcast
+   * @apiPermission public
+   * @apiName Broadcast
+   * @apiGroup JSON BCH
+   * @apiDescription Broadcast a transaction to the BCH network.
+   * The transaction should be encoded as a hexidecimal string.
+   *
+   * @apiExample Example usage:
+   * {"jsonrpc":"2.0","id":"555","method":"bch","params":{ "endpoint": "broadcast", "hex": "01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0704ffff001d0104ffffffff0100f2052a0100000043410496b538e853519c726a2c91e61ec11600ae1390813a627c66fb8be7947be63c52da7589379515d4e0a604f8141781e62294721166bf621e73a82cbf2342c858eeac00000000"}}
+   *
+   */
+  async broadcast (rpcData) {
+    try {
+      // console.log('createUser rpcData: ', rpcData)
+
+      const hex = rpcData.payload.params.hex
+
+      const data = await this.bchjs.RawTransactions.sendRawTransaction(hex)
+      // console.log(`data: ${JSON.stringify(data, null, 2)}`)
+
+      const retObj = data
+      retObj.status = 200
+
+      return retObj
+    } catch (err) {
+      // console.error('Error in createUser()')
+      // throw err
+
+      // Return an error response
+      return {
+        success: false,
+        status: 422,
+        message: err.message,
+        endpoint: 'broadcast'
+      }
+    }
+  }
+
+  /**
+   * @api {JSON} /bch Transaction
+   * @apiPermission public
+   * @apiName Transaction
+   * @apiGroup JSON BCH
+   * @apiDescription Get data about a specific transaction.
+   *
+   * @apiExample Example usage:
+   * {"jsonrpc":"2.0","id":"555","method":"bch","params":{ "endpoint": "transaction", "hex": "0e3e2357e806b6cdb1f70b54c3a3a17b6714ee1f0e68bebb44a74b1efd512098"}}
+   *
+   */
+  async transaction (rpcData) {
+    try {
+      // console.log('createUser rpcData: ', rpcData)
+
+      const txid = rpcData.payload.params.txid
+
+      const data = await this.bchjs.Transaction.get(txid)
+      // console.log(`data: ${JSON.stringify(data, null, 2)}`)
+
+      const retObj = data
+      retObj.status = 200
+
+      return retObj
+    } catch (err) {
+      // console.error('Error in createUser()')
+      // throw err
+
+      // Return an error response
+      return {
+        success: false,
+        status: 422,
+        message: err.message,
+        endpoint: 'transaction'
+      }
+    }
+  }
+}
+
+module.exports = BCHRPC

src/controllers/json-rpc/fulcrum/index.js

@@ -1,129 +0,0 @@
-/*
-  This is the JSON RPC router for the Fulcrum API
-*/
-
-// Public npm libraries
-const jsonrpc = require('jsonrpc-lite')
-const BCHJS = require('@psf/bch-js')
-
-// Local libraries
-// const UserLib = require('../../../use-cases/user')
-const Validators = require('../validators')
-const RateLimit = require('../rate-limit')
-
-class FulcrumRPC {
-  constructor (localConfig = {}) {
-    // Dependency Injection.
-    this.adapters = localConfig.adapters
-    if (!this.adapters) {
-      throw new Error(
-        'Instance of Adapters library required when instantiating Fulcrum JSON RPC Controller.'
-      )
-    }
-    this.useCases = localConfig.useCases
-    if (!this.useCases) {
-      throw new Error(
-        'Instance of Use Cases library required when instantiating Fulcrum JSON RPC Controller.'
-      )
-    }
-
-    // Encapsulate dependencies
-    this.userLib = this.useCases.user
-    this.jsonrpc = jsonrpc
-    this.validators = new Validators(localConfig)
-    this.rateLimit = new RateLimit()
-    this.bchjs = new BCHJS()
-  }
-
-  // Top-level router for this library. All other methods in this class are for
-  // a specific endpoint. This method routes incoming calls to one of those
-  // methods.
-  async fulcrumRouter (rpcData) {
-    let endpoint = 'unknown'
-    try {
-      // console.log('fulcrumRouter rpcData: ', rpcData)
-
-      endpoint = rpcData.payload.params.endpoint
-      let user
-
-      // Route the call based on the value of the method property.
-      switch (endpoint) {
-        case 'transactions':
-          await this.rateLimit.limiter(rpcData.from)
-          return await this.transactions(rpcData)
-
-        // case 'getAllUsers':
-        //   await this.validators.ensureUser(rpcData)
-        //   await this.rateLimit.limiter(rpcData.from)
-        //   return await this.getAll(rpcData)
-        //
-        // case 'getUser':
-        //   user = await this.validators.ensureUser(rpcData)
-        //   await this.rateLimit.limiter(rpcData.from)
-        //   return await this.getUser(rpcData, user)
-        //
-        // case 'updateUser':
-        //   user = await this.validators.ensureTargetUserOrAdmin(rpcData)
-        //   await this.rateLimit.limiter(rpcData.from)
-        //   return await this.updateUser(rpcData, user)
-        //
-        // case 'deleteUser':
-        //   user = await this.validators.ensureTargetUserOrAdmin(rpcData)
-        //   await this.rateLimit.limiter(rpcData.from)
-        //   return await this.deleteUser(rpcData, user)
-      }
-    } catch (err) {
-      console.error('Error in FulcrumRPC/rpcRouter()')
-      // throw err
-
-      return {
-        success: false,
-        status: err.status || 500,
-        message: err.message,
-        endpoint
-      }
-    }
-  }
-
-  /**
-   * @api {JSON} /fulcrum Transactions
-   * @apiPermission public
-   * @apiName Transactions
-   * @apiGroup JSON Fulcrum
-   * @apiDescription This endpoint wraps the bchjs.Electrumx.transactions([]) function.
-   *
-   * @apiExample Example usage:
-   * {"jsonrpc":"2.0","id":"555","method":"fulcrum","params":{ "endpoint": "transactions", "addresses": ["bitcoincash:qrl2nlsaayk6ekxn80pq0ks32dya8xfclyktem2mqj"]}}
-   *
-   */
-  async transactions (rpcData) {
-    try {
-      // console.log('createUser rpcData: ', rpcData)
-
-      const addrs = rpcData.payload.params.addresses
-
-      const data = await this.bchjs.Electrumx.transactions(addrs)
-      // console.log(`data: ${JSON.stringify(data, null, 2)}`)
-
-      const retObj = data
-      retObj.status = 200
-
-      return retObj
-    } catch (err) {
-      // console.error('Error in createUser()')
-      // throw err
-
-      // Return an error response
-      return {
-        success: false,
-        status: 422,
-        message: err.message,
-        endpoint: 'transactions'
-      }
-    }
-  }
-
-  // TODO create deleteUser()
-}
-
-module.exports = FulcrumRPC

src/controllers/json-rpc/index.js

@@ -10,7 +10,7 @@ const { wlogger } = require('../../adapters/wlogger')
 const UserController = require('./users')
 const AuthController = require('./auth')
 const AboutController = require('./about')
-const FulcrumController = require('./fulcrum')
+const BCHController = require('./bch')
 
 let _this
 
@@ -36,7 +36,7 @@ class JSONRPC {
     this.userController = new UserController(localConfig)
     this.authController = new AuthController(localConfig)
     this.aboutController = new AboutController()
-    this.fulcrumController = new FulcrumController(localConfig)
+    this.bchController = new BCHController(localConfig)
 
     _this = this
   }
@@ -83,8 +83,8 @@ class JSONRPC {
         case 'about':
           retObj = await _this.aboutController.aboutRouter(parsedData)
           break
-        case 'fulcrum':
-          retObj = await _this.fulcrumController.fulcrumRouter(parsedData)
+        case 'bch':
+          retObj = await _this.bchController.bchRouter(parsedData)
       }
 
       // console.log('retObj: ', retObj)

src/controllers/json-rpc/rate-limit.js

@@ -14,7 +14,7 @@ class RateLimit {
     // Set default rate limit options.
     this.defaultOptions = {
       interval: { min: 1 },
-      max: 1000, // 1000 RPM while prototyping.
+      max: 600, // 600 RPM while prototyping.
       onLimitReached: this.onLimitReached
     }
 
@@ -48,7 +48,7 @@ class RateLimit {
   onLimitReached () {
     try {
       const error = new Error() // Establish provided options as the default options.
-      error.message = 'Too many requests, please try again later.'
+      error.message = 'Too many requests, please slow down your requests.'
       error.status = 429
       throw error
     } catch (error) {

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

@@ -0,0 +1,238 @@
+/*
+  Controller for the /fulcrum REST API endpoints.
+*/
+
+const BCHJS = require('@psf/bch-js')
+
+let _this
+
+class BCHRESTController {
+  constructor (localConfig = {}) {
+    // Dependency Injection.
+    this.adapters = localConfig.adapters
+    if (!this.adapters) {
+      throw new Error(
+        'Instance of Adapters library required when instantiating BCH REST Controller.'
+      )
+    }
+    this.useCases = localConfig.useCases
+    if (!this.useCases) {
+      throw new Error(
+        'Instance of Use Cases library required when instantiating BCH REST Controller.'
+      )
+    }
+
+    this.bchjs = new BCHJS()
+
+    _this = this
+  }
+
+  /**
+   * @api {post} /bch/transactions Transactions
+   * @apiName Transactions
+   * @apiGroup REST BCH
+   * @apiDescription This endpoint wraps the bchjs.Electrumx.transactions([]) function.
+   *
+   * @apiExample Example usage:
+   * curl -H "Content-Type: application/json" -X POST -d '{ "addresses": ["bitcoincash:qrl2nlsaayk6ekxn80pq0ks32dya8xfclyktem2mqj"] }' localhost:5001/bch/transactions
+   *
+   * @apiSuccessExample {json} Success-Response:
+   *     HTTP/1.1 200 OK
+   *     {
+   *
+   *        success:true,
+   *        data: <data>
+   *     }
+   *
+   * @apiError UnprocessableEntity Missing required parameters
+   *
+   * @apiErrorExample {json} Error-Response:
+   *     HTTP/1.1 422 Unprocessable Entity
+   *     {
+   *       "status": 422,
+   *       "error": "Unprocessable Entity"
+   *     }
+   */
+  async transactions (ctx) {
+    try {
+      const addrs = ctx.request.body.addresses
+
+      const data = await _this.bchjs.Electrumx.transactions(addrs)
+      // console.log(`data: ${JSON.stringify(data, null, 2)}`)
+
+      ctx.body = data
+    } catch (err) {
+      _this.handleError(ctx, err)
+    }
+  }
+
+  /**
+   * @api {post} /bch/balance Balance
+   * @apiName Balance
+   * @apiGroup REST BCH
+   * @apiDescription This endpoint returns the balance in BCH for an address.
+   *
+   * @apiExample Example usage:
+   * curl -H "Content-Type: application/json" -X POST -d '{ "addresses": ["bitcoincash:qrl2nlsaayk6ekxn80pq0ks32dya8xfclyktem2mqj"] }' localhost:5001/bch/balance
+   *
+   * @apiSuccessExample {json} Success-Response:
+   *     HTTP/1.1 200 OK
+   *     {
+   *        success:true,
+   *        data: <data>
+   *     }
+   *
+   * @apiError UnprocessableEntity Missing required parameters
+   *
+   * @apiErrorExample {json} Error-Response:
+   *     HTTP/1.1 422 Unprocessable Entity
+   *     {
+   *       "status": 422,
+   *       "error": "Unprocessable Entity"
+   *     }
+   */
+  async balance (ctx) {
+    try {
+      const addrs = ctx.request.body.addresses
+
+      const data = await _this.bchjs.Electrumx.balance(addrs)
+      // console.log(`data: ${JSON.stringify(data, null, 2)}`)
+
+      ctx.body = data
+    } catch (err) {
+      _this.handleError(ctx, err)
+    }
+  }
+
+  /**
+   * @api {post} /bch/utxos Balance
+   * @apiName Utxos
+   * @apiGroup REST BCH
+   * @apiDescription This endpoint returns UTXOs held at an address, hydrated
+   * with token information.
+   *
+   * @apiExample Example usage:
+   * curl -H "Content-Type: application/json" -X POST -d '{ "address": "bitcoincash:qrl2nlsaayk6ekxn80pq0ks32dya8xfclyktem2mqj" }' localhost:5001/bch/utxos
+   *
+   * @apiSuccessExample {json} Success-Response:
+   *     HTTP/1.1 200 OK
+   *     {
+   *        success:true,
+   *        data: <data>
+   *     }
+   *
+   * @apiError UnprocessableEntity Missing required parameters
+   *
+   * @apiErrorExample {json} Error-Response:
+   *     HTTP/1.1 422 Unprocessable Entity
+   *     {
+   *       "status": 422,
+   *       "error": "Unprocessable Entity"
+   *     }
+   */
+  async utxos (ctx) {
+    try {
+      const address = ctx.request.body.address
+
+      const utxos = await _this.bchjs.Utxo.get(address)
+      // console.log(`utxos: ${JSON.stringify(utxos, null, 2)}`)
+
+      ctx.body = utxos
+    } catch (err) {
+      _this.handleError(ctx, err)
+    }
+  }
+
+  /**
+   * @api {post} /bch/broadcast Broadcast
+   * @apiName Broadcast
+   * @apiGroup REST BCH
+   * @apiDescription Broadcast a transaction to the BCH network.
+   * The transaction should be encoded as a hexidecimal string.
+   *
+   * @apiExample Example usage:
+   * curl -H "Content-Type: application/json" -X POST -d '{ "hex": "01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0704ffff001d0104ffffffff0100f2052a0100000043410496b538e853519c726a2c91e61ec11600ae1390813a627c66fb8be7947be63c52da7589379515d4e0a604f8141781e62294721166bf621e73a82cbf2342c858eeac00000000" }' localhost:5001/bch/broadcast
+   *
+   * @apiSuccessExample {json} Success-Response:
+   *     HTTP/1.1 200 OK
+   *     {
+   *        success:true,
+   *        data: <data>
+   *     }
+   *
+   * @apiError UnprocessableEntity Missing required parameters
+   *
+   * @apiErrorExample {json} Error-Response:
+   *     HTTP/1.1 422 Unprocessable Entity
+   *     {
+   *       "status": 422,
+   *       "error": "Unprocessable Entity"
+   *     }
+   */
+  async broadcast (ctx) {
+    try {
+      const hex = ctx.request.body.hex
+
+      const txid = await _this.bchjs.RawTransactions.sendRawTransaction(hex)
+      // console.log(`utxos: ${JSON.stringify(utxos, null, 2)}`)
+
+      ctx.body = txid
+    } catch (err) {
+      _this.handleError(ctx, err)
+    }
+  }
+
+  /**
+   * @api {post} /bch/transaction Transaction
+   * @apiName Transaction
+   * @apiGroup REST BCH
+   * @apiDescription Get data about a specific transaction.
+   *
+   * @apiExample Example usage:
+   * curl -H "Content-Type: application/json" -X POST -d '{ "txid": "0e3e2357e806b6cdb1f70b54c3a3a17b6714ee1f0e68bebb44a74b1efd512098" }' localhost:5001/bch/transaction
+   *
+   * @apiSuccessExample {json} Success-Response:
+   *     HTTP/1.1 200 OK
+   *     {
+   *        success:true,
+   *        data: <data>
+   *     }
+   *
+   * @apiError UnprocessableEntity Missing required parameters
+   *
+   * @apiErrorExample {json} Error-Response:
+   *     HTTP/1.1 422 Unprocessable Entity
+   *     {
+   *       "status": 422,
+   *       "error": "Unprocessable Entity"
+   *     }
+   */
+  async transaction (ctx) {
+    try {
+      const txid = ctx.request.body.txid
+
+      const data = await _this.bchjs.Transaction.get(txid)
+      // console.log(`utxos: ${JSON.stringify(utxos, null, 2)}`)
+
+      ctx.body = data
+    } catch (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 = BCHRESTController

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

@@ -6,21 +6,21 @@
 const Router = require('koa-router')
 
 // Local libraries.
-const FulcrumRESTController = require('./controller')
+const BCHRESTController = require('./controller')
 
-class FulcrumRouter {
+class BCHRouter {
   constructor (localConfig = {}) {
     // Dependency Injection.
     this.adapters = localConfig.adapters
     if (!this.adapters) {
       throw new Error(
-        'Instance of Adapters library required when instantiating Fulcrum REST Controller.'
+        'Instance of Adapters library required when instantiating BCH REST Controller.'
       )
     }
     this.useCases = localConfig.useCases
     if (!this.useCases) {
       throw new Error(
-        'Instance of Use Cases library required when instantiating Fulcrum REST Controller.'
+        'Instance of Use Cases library required when instantiating BCH REST Controller.'
       )
     }
 
@@ -30,10 +30,10 @@ class FulcrumRouter {
     }
 
     // Encapsulate dependencies.
-    this.fulcrumRESTController = new FulcrumRESTController(dependencies)
+    this.bchRESTController = new BCHRESTController(dependencies)
 
     // Instantiate the router and set the base route.
-    const baseUrl = '/fulcrum'
+    const baseUrl = '/bch'
     this.router = new Router({ prefix: baseUrl })
   }
 
@@ -45,7 +45,11 @@ class FulcrumRouter {
     }
 
     // Define the routes and attach the controller.
-    this.router.post('/transactions', this.fulcrumRESTController.transactions)
+    this.router.post('/transactions', this.bchRESTController.transactions)
+    this.router.post('/balance', this.bchRESTController.balance)
+    this.router.post('/utxos', this.bchRESTController.utxos)
+    this.router.post('/broadcast', this.bchRESTController.broadcast)
+    this.router.post('/transaction', this.bchRESTController.transaction)
 
     // Attach the Controller routes to the Koa app.
     app.use(this.router.routes())
@@ -53,4 +57,4 @@ class FulcrumRouter {
   }
 }
 
-module.exports = FulcrumRouter
+module.exports = BCHRouter

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

@@ -1,84 +0,0 @@
-/*
-  Controller for the /fulcrum REST API endpoints.
-*/
-
-const BCHJS = require('@psf/bch-js')
-
-let _this
-
-class FulcrumRESTController {
-  constructor (localConfig = {}) {
-    // Dependency Injection.
-    this.adapters = localConfig.adapters
-    if (!this.adapters) {
-      throw new Error(
-        'Instance of Adapters library required when instantiating Fulcrum REST Controller.'
-      )
-    }
-    this.useCases = localConfig.useCases
-    if (!this.useCases) {
-      throw new Error(
-        'Instance of Use Cases library required when instantiating Fulcrum REST Controller.'
-      )
-    }
-
-    this.bchjs = new BCHJS()
-
-    _this = this
-  }
-
-  /**
-   * @api {post} /fulcrum/transactions Transactions
-   * @apiName Transactions
-   * @apiGroup REST Fulcrum
-   * @apiDescription This endpoint wraps the bchjs.Electrumx.transactions([]) function.
-   *
-   * @apiExample Example usage:
-   * curl -H "Content-Type: application/json" -X POST -d '{ "addresses": ["bitcoincash:qrl2nlsaayk6ekxn80pq0ks32dya8xfclyktem2mqj"] }' localhost:5001/fulcrum/transactions
-   *
-   * @apiSuccessExample {json} Success-Response:
-   *     HTTP/1.1 200 OK
-   *     {
-   *
-   *        success:true,
-   *        data: <data>
-   *     }
-   *
-   * @apiError UnprocessableEntity Missing required parameters
-   *
-   * @apiErrorExample {json} Error-Response:
-   *     HTTP/1.1 422 Unprocessable Entity
-   *     {
-   *       "status": 422,
-   *       "error": "Unprocessable Entity"
-   *     }
-   */
-  async transactions (ctx) {
-    try {
-      const addrs = ctx.request.body.addresses
-
-      const data = await _this.bchjs.Electrumx.transactions(addrs)
-      // console.log(`data: ${JSON.stringify(data, null, 2)}`)
-
-      ctx.body = data
-    } catch (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 = FulcrumRESTController

src/controllers/rest-api/index.js

@@ -11,7 +11,7 @@ const AuthRESTController = require('./auth')
 const UserRouter = require('./users')
 const ContactRESTController = require('./contact')
 const LogsRESTController = require('./logs')
-const FulcrumRESTController = require('./fulcrum')
+const BCHRESTController = require('./bch')
 
 class RESTControllers {
   constructor (localConfig = {}) {
@@ -55,8 +55,8 @@ class RESTControllers {
     logsRESTController.attach(app)
 
     // Attach the REST API Controllers associated with the /fulcrum route
-    const fulcrumRESTController = new FulcrumRESTController(dependencies)
-    fulcrumRESTController.attach(app)
+    const bchRESTController = new BCHRESTController(dependencies)
+    bchRESTController.attach(app)
   }
 }
 

test/unit/controllers/json-rpc/a14-rate-limits.js

@@ -69,7 +69,7 @@ describe('#rate-limit', () => {
         assert.equal(error.status, 429)
         assert.include(
           error.message,
-          'Too many requests, please try again later.'
+          'Too many requests, please slow down your requests.'
         )
       }
     })
@@ -101,7 +101,7 @@ describe('#rate-limit', () => {
       } catch (error) {
         assert.include(
           error.message,
-          'Too many requests, please try again later.'
+          'Too many requests, please slow down your requests.'
         )
       }
     })

test/unit/controllers/json-rpc/bch.json-rpc.controller.unit.js

@@ -0,0 +1,423 @@
+/*
+  Unit tests for the json-rpc/auth/index.js file.
+*/
+
+// Public npm libraries
+const jsonrpc = require('jsonrpc-lite')
+const sinon = require('sinon')
+const assert = require('chai').assert
+const { v4: uid } = require('uuid')
+
+// Set the environment variable to signal this is a test.
+process.env.SVC_ENV = 'test'
+
+// Local libraries
+const BCHRPC = require('../../../../src/controllers/json-rpc/bch')
+const RateLimit = require('../../../../src/controllers/json-rpc/rate-limit')
+const adapters = require('../../mocks/adapters')
+const UseCasesMock = require('../../mocks/use-cases')
+
+describe('#BCHRPC', () => {
+  let uut
+  let sandbox
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox()
+
+    const useCases = new UseCasesMock()
+
+    uut = new BCHRPC({ adapters, useCases })
+    uut.rateLimit = new RateLimit({ max: 100 })
+  })
+
+  afterEach(() => sandbox.restore())
+
+  describe('#constructor', () => {
+    it('should throw an error if adapters are not passed in', () => {
+      try {
+        uut = new BCHRPC()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(
+          err.message,
+          'Instance of Adapters library required when instantiating BCH JSON RPC Controller.'
+        )
+      }
+    })
+
+    it('should throw an error if useCases are not passed in', () => {
+      try {
+        uut = new BCHRPC({ adapters })
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(
+          err.message,
+          'Instance of Use Cases library required when instantiating BCH JSON RPC Controller.'
+        )
+      }
+    })
+  })
+
+  describe('#bchRouter', () => {
+    it('should route to the transactions method', async () => {
+      // Mock dependencies
+      sandbox.stub(uut, 'transactions').resolves(true)
+
+      // Generate the parsed data that the main router would pass to this
+      // endpoint.
+      const id = uid()
+      const txCall = jsonrpc.request(id, 'bch', {
+        endpoint: 'transactions'
+      })
+      const jsonStr = JSON.stringify(txCall, null, 2)
+      const rpcData = jsonrpc.parse(jsonStr)
+      rpcData.from = 'Origin request'
+
+      const result = await uut.bchRouter(rpcData)
+
+      assert.equal(result, true)
+    })
+
+    it('should route to the balance method', async () => {
+      // Mock dependencies
+      sandbox.stub(uut, 'balance').resolves(true)
+
+      // Generate the parsed data that the main router would pass to this
+      // endpoint.
+      const id = uid()
+      const txCall = jsonrpc.request(id, 'bch', {
+        endpoint: 'balance'
+      })
+      const jsonStr = JSON.stringify(txCall, null, 2)
+      const rpcData = jsonrpc.parse(jsonStr)
+      rpcData.from = 'Origin request'
+
+      const result = await uut.bchRouter(rpcData)
+
+      assert.equal(result, true)
+    })
+
+    it('should route to the utxos method', async () => {
+      // Mock dependencies
+      sandbox.stub(uut, 'utxos').resolves(true)
+
+      // Generate the parsed data that the main router would pass to this
+      // endpoint.
+      const id = uid()
+      const txCall = jsonrpc.request(id, 'bch', {
+        endpoint: 'utxos'
+      })
+      const jsonStr = JSON.stringify(txCall, null, 2)
+      const rpcData = jsonrpc.parse(jsonStr)
+      rpcData.from = 'Origin request'
+
+      const result = await uut.bchRouter(rpcData)
+
+      assert.equal(result, true)
+    })
+
+    it('should route to the broadcast method', async () => {
+      // Mock dependencies
+      sandbox.stub(uut, 'broadcast').resolves(true)
+
+      // Generate the parsed data that the main router would pass to this
+      // endpoint.
+      const id = uid()
+      const rpcCall = jsonrpc.request(id, 'bch', {
+        endpoint: 'broadcast'
+      })
+      const jsonStr = JSON.stringify(rpcCall, null, 2)
+      const rpcData = jsonrpc.parse(jsonStr)
+      rpcData.from = 'Origin request'
+
+      const result = await uut.bchRouter(rpcData)
+
+      assert.equal(result, true)
+    })
+
+    it('should route to the transaction method', async () => {
+      // Mock dependencies
+      sandbox.stub(uut, 'transaction').resolves(true)
+
+      // Generate the parsed data that the main router would pass to this
+      // endpoint.
+      const id = uid()
+      const rpcCall = jsonrpc.request(id, 'bch', {
+        endpoint: 'transaction'
+      })
+      const jsonStr = JSON.stringify(rpcCall, null, 2)
+      const rpcData = jsonrpc.parse(jsonStr)
+      rpcData.from = 'Origin request'
+
+      const result = await uut.bchRouter(rpcData)
+
+      assert.equal(result, true)
+    })
+
+    it('should return 500 status on routing issue', async () => {
+      // Mock dependencies
+      sandbox.stub(uut, 'transactions').rejects(new Error('test error'))
+
+      // Generate the parsed data that the main router would pass to this
+      // endpoint.
+      const id = uid()
+      const txCall = jsonrpc.request(id, 'bch', {
+        endpoint: 'transactions'
+      })
+      const jsonStr = JSON.stringify(txCall, null, 2)
+      const rpcData = jsonrpc.parse(jsonStr)
+      rpcData.from = 'Origin request'
+
+      const result = await uut.bchRouter(rpcData)
+
+      assert.equal(result.success, false)
+      assert.equal(result.status, 500)
+      assert.equal(result.message, 'test error')
+      assert.equal(result.endpoint, 'transactions')
+    })
+  })
+
+  describe('#transactions', () => {
+    it('should return data from bchjs', async () => {
+      // Mock dependencies
+      sandbox
+        .stub(uut.bchjs.Electrumx, 'transactions')
+        .resolves({ success: true })
+
+      // Generate the parsed data that the main router would pass to this
+      // endpoint.
+      const id = uid()
+      const txCall = jsonrpc.request(id, 'bch', {
+        endpoint: 'transactions',
+        addresses: 'testAddr'
+      })
+      const jsonStr = JSON.stringify(txCall, null, 2)
+      const rpcData = jsonrpc.parse(jsonStr)
+
+      const response = await uut.transactions(rpcData)
+      // console.log('response: ', response)
+
+      assert.equal(response.success, true)
+      assert.equal(response.status, 200)
+    })
+
+    it('should return an error for invalid address', async () => {
+      // Force an error
+      sandbox
+        .stub(uut.bchjs.Electrumx, 'transactions')
+        .rejects(new Error('Invalid address'))
+
+      // Generate the parsed data that the main router would pass to this
+      // endpoint.
+      const id = uid()
+      const txCall = jsonrpc.request(id, 'bch', {
+        endpoint: 'transactions',
+        addresses: 'testAddr'
+      })
+      const jsonStr = JSON.stringify(txCall, null, 2)
+      const rpcData = jsonrpc.parse(jsonStr)
+
+      const response = await uut.transactions(rpcData)
+      // console.log('response: ', response)
+
+      assert.equal(response.success, false)
+      assert.equal(response.status, 422)
+      assert.equal(response.message, 'Invalid address')
+      assert.equal(response.endpoint, 'transactions')
+    })
+  })
+
+  describe('#balance', () => {
+    it('should return data from bchjs', async () => {
+      // Mock dependencies
+      sandbox.stub(uut.bchjs.Electrumx, 'balance').resolves({ success: true })
+
+      // Generate the parsed data that the main router would pass to this
+      // endpoint.
+      const id = uid()
+      const rpcCall = jsonrpc.request(id, 'bch', {
+        endpoint: 'balance',
+        addresses: 'testAddr'
+      })
+      const jsonStr = JSON.stringify(rpcCall, null, 2)
+      const rpcData = jsonrpc.parse(jsonStr)
+
+      const response = await uut.balance(rpcData)
+      // console.log('response: ', response)
+
+      assert.equal(response.success, true)
+      assert.equal(response.status, 200)
+    })
+
+    it('should return an error for invalid address', async () => {
+      // Force an error
+      sandbox
+        .stub(uut.bchjs.Electrumx, 'balance')
+        .rejects(new Error('Invalid address'))
+
+      // Generate the parsed data that the main router would pass to this
+      // endpoint.
+      const id = uid()
+      const rpcCall = jsonrpc.request(id, 'bch', {
+        endpoint: 'balance',
+        addresses: 'testAddr'
+      })
+      const jsonStr = JSON.stringify(rpcCall, null, 2)
+      const rpcData = jsonrpc.parse(jsonStr)
+
+      const response = await uut.balance(rpcData)
+      // console.log('response: ', response)
+
+      assert.equal(response.success, false)
+      assert.equal(response.status, 422)
+      assert.equal(response.message, 'Invalid address')
+      assert.equal(response.endpoint, 'balance')
+    })
+  })
+
+  describe('#utxos', () => {
+    it('should return data from bchjs', async () => {
+      // Mock dependencies
+      sandbox.stub(uut.bchjs.Utxo, 'get').resolves({ success: true })
+
+      // Generate the parsed data that the main router would pass to this
+      // endpoint.
+      const id = uid()
+      const rpcCall = jsonrpc.request(id, 'bch', {
+        endpoint: 'utxos',
+        addresses: 'testAddr'
+      })
+      const jsonStr = JSON.stringify(rpcCall, null, 2)
+      const rpcData = jsonrpc.parse(jsonStr)
+
+      const response = await uut.utxos(rpcData)
+      // console.log('response: ', response)
+
+      assert.equal(response.success, true)
+      assert.equal(response.status, 200)
+    })
+
+    it('should return an error for invalid address', async () => {
+      // Force an error
+      sandbox.stub(uut.bchjs.Utxo, 'get').rejects(new Error('Invalid address'))
+
+      // Generate the parsed data that the main router would pass to this
+      // endpoint.
+      const id = uid()
+      const rpcCall = jsonrpc.request(id, 'bch', {
+        endpoint: 'utxos',
+        addresses: 'testAddr'
+      })
+      const jsonStr = JSON.stringify(rpcCall, null, 2)
+      const rpcData = jsonrpc.parse(jsonStr)
+
+      const response = await uut.utxos(rpcData)
+      // console.log('response: ', response)
+
+      assert.equal(response.success, false)
+      assert.equal(response.status, 422)
+      assert.equal(response.message, 'Invalid address')
+      assert.equal(response.endpoint, 'utxos')
+    })
+  })
+
+  describe('#broadcast', () => {
+    it('should return data from bchjs', async () => {
+      // Mock dependencies
+      sandbox
+        .stub(uut.bchjs.RawTransactions, 'sendRawTransaction')
+        .resolves({ success: true })
+
+      // Generate the parsed data that the main router would pass to this
+      // endpoint.
+      const id = uid()
+      const rpcCall = jsonrpc.request(id, 'bch', {
+        endpoint: 'broadcast',
+        hex: 'testData'
+      })
+      const jsonStr = JSON.stringify(rpcCall, null, 2)
+      const rpcData = jsonrpc.parse(jsonStr)
+
+      const response = await uut.broadcast(rpcData)
+      // console.log('response: ', response)
+
+      assert.equal(response.success, true)
+      assert.equal(response.status, 200)
+    })
+
+    it('should return an error for invalid input', async () => {
+      // Force an error
+      sandbox
+        .stub(uut.bchjs.RawTransactions, 'sendRawTransaction')
+        .rejects(new Error('Invalid data'))
+
+      // Generate the parsed data that the main router would pass to this
+      // endpoint.
+      const id = uid()
+      const rpcCall = jsonrpc.request(id, 'bch', {
+        endpoint: 'broadcast',
+        hex: 'testHex'
+      })
+      const jsonStr = JSON.stringify(rpcCall, null, 2)
+      const rpcData = jsonrpc.parse(jsonStr)
+
+      const response = await uut.broadcast(rpcData)
+      // console.log('response: ', response)
+
+      assert.equal(response.success, false)
+      assert.equal(response.status, 422)
+      assert.equal(response.message, 'Invalid data')
+      assert.equal(response.endpoint, 'broadcast')
+    })
+  })
+
+  describe('#transaction', () => {
+    it('should return data from bchjs', async () => {
+      // Mock dependencies
+      sandbox.stub(uut.bchjs.Transaction, 'get').resolves({ success: true })
+
+      // Generate the parsed data that the main router would pass to this
+      // endpoint.
+      const id = uid()
+      const rpcCall = jsonrpc.request(id, 'bch', {
+        endpoint: 'transaction',
+        txid: 'testData'
+      })
+      const jsonStr = JSON.stringify(rpcCall, null, 2)
+      const rpcData = jsonrpc.parse(jsonStr)
+
+      const response = await uut.transaction(rpcData)
+      // console.log('response: ', response)
+
+      assert.equal(response.success, true)
+      assert.equal(response.status, 200)
+    })
+
+    it('should return an error for invalid input', async () => {
+      // Force an error
+      sandbox
+        .stub(uut.bchjs.Transaction, 'get')
+        .rejects(new Error('Invalid data'))
+
+      // Generate the parsed data that the main router would pass to this
+      // endpoint.
+      const id = uid()
+      const rpcCall = jsonrpc.request(id, 'bch', {
+        endpoint: 'transaction',
+        txid: 'testTxid'
+      })
+      const jsonStr = JSON.stringify(rpcCall, null, 2)
+      const rpcData = jsonrpc.parse(jsonStr)
+
+      const response = await uut.transaction(rpcData)
+      // console.log('response: ', response)
+
+      assert.equal(response.success, false)
+      assert.equal(response.status, 422)
+      assert.equal(response.message, 'Invalid data')
+      assert.equal(response.endpoint, 'transaction')
+    })
+  })
+})

test/unit/controllers/json-rpc/fulcrum.json-rpc.controller.unit.js

@@ -1,248 +0,0 @@
-/*
-  Unit tests for the json-rpc/auth/index.js file.
-*/
-
-// Public npm libraries
-const jsonrpc = require('jsonrpc-lite')
-const sinon = require('sinon')
-const assert = require('chai').assert
-const { v4: uid } = require('uuid')
-
-// Set the environment variable to signal this is a test.
-process.env.SVC_ENV = 'test'
-
-// Local libraries
-const FulcrumRPC = require('../../../../src/controllers/json-rpc/fulcrum')
-const RateLimit = require('../../../../src/controllers/json-rpc/rate-limit')
-const adapters = require('../../mocks/adapters')
-const UseCasesMock = require('../../mocks/use-cases')
-
-describe('#FulcrumRPC', () => {
-  let uut
-  let sandbox
-
-  beforeEach(() => {
-    sandbox = sinon.createSandbox()
-
-    const useCases = new UseCasesMock()
-
-    uut = new FulcrumRPC({ adapters, useCases })
-    uut.rateLimit = new RateLimit({ max: 100 })
-  })
-
-  afterEach(() => sandbox.restore())
-
-  describe('#constructor', () => {
-    it('should throw an error if adapters are not passed in', () => {
-      try {
-        uut = new FulcrumRPC()
-
-        assert.fail('Unexpected code path')
-      } catch (err) {
-        assert.include(
-          err.message,
-          'Instance of Adapters library required when instantiating Fulcrum JSON RPC Controller.'
-        )
-      }
-    })
-
-    it('should throw an error if useCases are not passed in', () => {
-      try {
-        uut = new FulcrumRPC({ adapters })
-
-        assert.fail('Unexpected code path')
-      } catch (err) {
-        assert.include(
-          err.message,
-          'Instance of Use Cases library required when instantiating Fulcrum JSON RPC Controller.'
-        )
-      }
-    })
-  })
-
-  describe('#fulcrumRouter', () => {
-    it('should route to the transactions method', async () => {
-      // Mock dependencies
-      sandbox.stub(uut, 'transactions').resolves(true)
-
-      // Generate the parsed data that the main router would pass to this
-      // endpoint.
-      const id = uid()
-      const txCall = jsonrpc.request(id, 'fulcrum', {
-        endpoint: 'transactions'
-      })
-      const jsonStr = JSON.stringify(txCall, null, 2)
-      const rpcData = jsonrpc.parse(jsonStr)
-      rpcData.from = 'Origin request'
-
-      const result = await uut.fulcrumRouter(rpcData)
-
-      assert.equal(result, true)
-    })
-
-    it('should return 500 status on routing issue', async () => {
-      // Mock dependencies
-      sandbox.stub(uut, 'transactions').rejects(new Error('test error'))
-
-      // Generate the parsed data that the main router would pass to this
-      // endpoint.
-      const id = uid()
-      const txCall = jsonrpc.request(id, 'fulcrum', {
-        endpoint: 'transactions'
-      })
-      const jsonStr = JSON.stringify(txCall, null, 2)
-      const rpcData = jsonrpc.parse(jsonStr)
-      rpcData.from = 'Origin request'
-
-      const result = await uut.fulcrumRouter(rpcData)
-
-      assert.equal(result.success, false)
-      assert.equal(result.status, 500)
-      assert.equal(result.message, 'test error')
-      assert.equal(result.endpoint, 'transactions')
-    })
-  })
-
-  describe('#transactions', () => {
-    it('should return data from bchjs', async () => {
-      // Mock dependencies
-      sandbox
-        .stub(uut.bchjs.Electrumx, 'transactions')
-        .resolves({ success: true })
-
-      // Generate the parsed data that the main router would pass to this
-      // endpoint.
-      const id = uid()
-      const txCall = jsonrpc.request(id, 'fulcrum', {
-        endpoint: 'transactions',
-        addresses: 'testAddr'
-      })
-      const jsonStr = JSON.stringify(txCall, null, 2)
-      const rpcData = jsonrpc.parse(jsonStr)
-
-      const response = await uut.transactions(rpcData)
-      // console.log('response: ', response)
-
-      assert.equal(response.success, true)
-      assert.equal(response.status, 200)
-    })
-
-    it('should return an error for invalid address', async () => {
-      // Force an error
-      sandbox
-        .stub(uut.bchjs.Electrumx, 'transactions')
-        .rejects(new Error('Invalid address'))
-
-      // Generate the parsed data that the main router would pass to this
-      // endpoint.
-      const id = uid()
-      const txCall = jsonrpc.request(id, 'fulcrum', {
-        endpoint: 'transactions',
-        addresses: 'testAddr'
-      })
-      const jsonStr = JSON.stringify(txCall, null, 2)
-      const rpcData = jsonrpc.parse(jsonStr)
-
-      const response = await uut.transactions(rpcData)
-      console.log('response: ', response)
-
-      assert.equal(response.success, false)
-      assert.equal(response.status, 422)
-      assert.equal(response.message, 'Invalid address')
-      assert.equal(response.endpoint, 'transactions')
-    })
-  })
-
-  // describe('#authUser', () => {
-  //   it('should return a JWT token if user successfully authenticates', async () => {
-  //     // Generate the parsed data that the main router would pass to this
-  //     // endpoint.
-  //     const id = uid()
-  //     const authCall = jsonrpc.request(id, 'auth', {
-  //       endpoint: 'authUser',
-  //       login: 'test543@test.com',
-  //       password: 'password'
-  //     })
-  //     const jsonStr = JSON.stringify(authCall, null, 2)
-  //     const rpcData = jsonrpc.parse(jsonStr)
-  //
-  //     const response = await uut.authUser(rpcData)
-  //     // console.log('response: ', response)
-  //
-  //     assert.equal(response.endpoint, 'authUser')
-  //     assert.property(response, 'userId')
-  //     // assert.equal(response.userType, 'user')
-  //     assert.property(response, 'userName')
-  //     assert.property(response, 'userEmail')
-  //     assert.property(response, 'apiToken')
-  //     assert.equal(response.status, 200)
-  //     assert.equal(response.success, true)
-  //     assert.property(response, 'message')
-  //   })
-  //
-  //   it('should return an error for invalid credentials', async () => {
-  //     // Generate the parsed data that the main router would pass to this
-  //     // endpoint.
-  //     const id = uid()
-  //     const authCall = jsonrpc.request(id, 'auth', {
-  //       endpoint: 'authUser',
-  //       login: 'test543@test.com',
-  //       password: 'badpassword'
-  //     })
-  //     const jsonStr = JSON.stringify(authCall, null, 2)
-  //     const rpcData = jsonrpc.parse(jsonStr)
-  //
-  //     // Force an error.
-  //     sandbox
-  //       .stub(uut.userLib, 'authUser')
-  //       .rejects(new Error('Login credential do not match'))
-  //
-  //     const response = await uut.authUser(rpcData)
-  //     // console.log('response: ', response)
-  //
-  //     assert.equal(response.success, false)
-  //     assert.equal(response.status, 422)
-  //     assert.equal(response.message, 'Login credential do not match')
-  //     assert.equal(response.endpoint, 'authUser')
-  //   })
-  //
-  //   it('should throw an error if login is not provided', async () => {
-  //     // Generate the parsed data that the main router would pass to this
-  //     // endpoint.
-  //     const id = uid()
-  //     const authCall = jsonrpc.request(id, 'auth', {
-  //       endpoint: 'authUser'
-  //     })
-  //     const jsonStr = JSON.stringify(authCall, null, 2)
-  //     const rpcData = jsonrpc.parse(jsonStr)
-  //
-  //     const response = await uut.authUser(rpcData)
-  //     // console.log('response: ', response)
-  //
-  //     assert.equal(response.success, false)
-  //     assert.equal(response.status, 422)
-  //     assert.equal(response.message, 'login must be specified')
-  //     assert.equal(response.endpoint, 'authUser')
-  //   })
-  //
-  //   it('should throw an error if password is not provided', async () => {
-  //     // Generate the parsed data that the main router would pass to this
-  //     // endpoint.
-  //     const id = uid()
-  //     const authCall = jsonrpc.request(id, 'auth', {
-  //       endpoint: 'authUser',
-  //       login: 'test543@test.com'
-  //     })
-  //     const jsonStr = JSON.stringify(authCall, null, 2)
-  //     const rpcData = jsonrpc.parse(jsonStr)
-  //
-  //     const response = await uut.authUser(rpcData)
-  //     // console.log('response: ', response)
-  //
-  //     assert.equal(response.success, false)
-  //     assert.equal(response.status, 422)
-  //     assert.equal(response.message, 'password must be specified')
-  //     assert.equal(response.endpoint, 'authUser')
-  //   })
-  // })
-})

test/unit/controllers/json-rpc/json-rpc.controller.unit.js

@@ -180,15 +180,15 @@ describe('#JSON RPC', () => {
       assert.equal(obj.id, id)
     })
 
-    it('should route to fulcrum handler', async () => {
+    it('should route to bch handler', async () => {
       const id = uid()
-      const userCall = jsonrpc.request(id, 'fulcrum', {
+      const userCall = jsonrpc.request(id, 'bch', {
         endpoint: 'transactions'
       })
       const jsonStr = JSON.stringify(userCall, null, 2)
 
       // Mock the controller.
-      sandbox.stub(uut.fulcrumController, 'fulcrumRouter').resolves('true')
+      sandbox.stub(uut.bchController, 'bchRouter').resolves('true')
 
       // Force ipfs-coord communication.
       uut.ipfsCoord.ipfs = {
@@ -204,7 +204,7 @@ describe('#JSON RPC', () => {
       // console.log('obj: ', obj)
 
       assert.equal(obj.result.value, 'true')
-      assert.equal(obj.result.method, 'fulcrum')
+      assert.equal(obj.result.method, 'bch')
       assert.equal(obj.id, id)
     })
   })

test/unit/controllers/rest-api/bch/bch.rest.controller.unit.js

@@ -0,0 +1,262 @@
+/*
+  Unit tests for the REST API handler for the /users endpoints.
+*/
+
+// Public npm libraries
+const assert = require('chai').assert
+const sinon = require('sinon')
+
+// Local support libraries
+const adapters = require('../../../mocks/adapters')
+const UseCasesMock = require('../../../mocks/use-cases')
+// const app = require('../../../mocks/app-mock')
+
+const BCHRESTController = require('../../../../../src/controllers/rest-api/bch/controller')
+let uut
+let sandbox
+let ctx
+
+const mockContext = require('../../../../unit/mocks/ctx-mock').context
+
+describe('#BCH-REST-Router', () => {
+  // const testUser = {}
+
+  beforeEach(() => {
+    const useCases = new UseCasesMock()
+    uut = new BCHRESTController({ adapters, useCases })
+
+    sandbox = sinon.createSandbox()
+
+    // Mock the context object.
+    ctx = mockContext()
+  })
+
+  afterEach(() => sandbox.restore())
+
+  describe('#constructor', () => {
+    it('should throw an error if adapters are not passed in', () => {
+      try {
+        uut = new BCHRESTController()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(
+          err.message,
+          'Instance of Adapters library required when instantiating BCH REST Controller.'
+        )
+      }
+    })
+
+    it('should throw an error if useCases are not passed in', () => {
+      try {
+        uut = new BCHRESTController({ adapters })
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(
+          err.message,
+          'Instance of Use Cases library required when instantiating BCH REST Controller.'
+        )
+      }
+    })
+  })
+
+  describe('#transactions', () => {
+    it('should return data from bchjs', async () => {
+      // Mock dependencies
+      sandbox
+        .stub(uut.bchjs.Electrumx, 'transactions')
+        .resolves({ success: true })
+
+      ctx.request.body = {
+        addresses: 'testAddr'
+      }
+
+      await uut.transactions(ctx)
+      // console.log('ctx.body: ', ctx.body)
+
+      assert.equal(ctx.body.success, true)
+    })
+
+    it('should catch and throw an error', async () => {
+      try {
+        // Force an error
+        sandbox
+          .stub(uut.bchjs.Electrumx, 'transactions')
+          .rejects(new Error('test error'))
+
+        ctx.request.body = {
+          addresses: 'testAddr'
+        }
+
+        await uut.transactions(ctx)
+      } catch (err) {
+        // console.log('err: ', err)
+        assert.include(err.message, 'test error')
+      }
+    })
+  })
+
+  describe('#balance', () => {
+    it('should return data from bchjs', async () => {
+      // Mock dependencies
+      sandbox.stub(uut.bchjs.Electrumx, 'balance').resolves({ success: true })
+
+      ctx.request.body = {
+        addresses: 'testAddr'
+      }
+
+      await uut.balance(ctx)
+      // console.log('ctx.body: ', ctx.body)
+
+      assert.equal(ctx.body.success, true)
+    })
+
+    it('should catch and throw an error', async () => {
+      try {
+        // Force an error
+        sandbox
+          .stub(uut.bchjs.Electrumx, 'balance')
+          .rejects(new Error('test error'))
+
+        ctx.request.body = {
+          addresses: 'testAddr'
+        }
+
+        await uut.balance(ctx)
+      } catch (err) {
+        // console.log('err: ', err)
+        assert.include(err.message, 'test error')
+      }
+    })
+  })
+
+  describe('#utxos', () => {
+    it('should return data from bchjs', async () => {
+      // Mock dependencies
+      sandbox.stub(uut.bchjs.Utxo, 'get').resolves({ success: true })
+
+      ctx.request.body = {
+        addresses: 'testAddr'
+      }
+
+      await uut.utxos(ctx)
+      // console.log('ctx.body: ', ctx.body)
+
+      assert.equal(ctx.body.success, true)
+    })
+
+    it('should catch and throw an error', async () => {
+      try {
+        // Force an error
+        sandbox.stub(uut.bchjs.Utxo, 'get').rejects(new Error('test error'))
+
+        ctx.request.body = {
+          addresses: 'testAddr'
+        }
+
+        await uut.utxos(ctx)
+      } catch (err) {
+        // console.log('err: ', err)
+        assert.include(err.message, 'test error')
+      }
+    })
+  })
+
+  describe('#broadcast', () => {
+    it('should return data from bchjs', async () => {
+      // Mock dependencies
+      sandbox
+        .stub(uut.bchjs.RawTransactions, 'sendRawTransaction')
+        .resolves({ success: true })
+
+      ctx.request.body = {
+        hex: 'testData'
+      }
+
+      await uut.broadcast(ctx)
+      // console.log('ctx.body: ', ctx.body)
+
+      assert.equal(ctx.body.success, true)
+    })
+
+    it('should catch and throw an error', async () => {
+      try {
+        // Force an error
+        sandbox
+          .stub(uut.bchjs.RawTransactions, 'sendRawTransaction')
+          .rejects(new Error('test error'))
+
+        ctx.request.body = {
+          hex: 'testData'
+        }
+
+        await uut.broadcast(ctx)
+      } catch (err) {
+        // console.log('err: ', err)
+        assert.include(err.message, 'test error')
+      }
+    })
+  })
+
+  describe('#transaction', () => {
+    it('should return data from bchjs', async () => {
+      // Mock dependencies
+      sandbox.stub(uut.bchjs.Transaction, 'get').resolves({ success: true })
+
+      ctx.request.body = {
+        txid: 'testData'
+      }
+
+      await uut.transaction(ctx)
+      // console.log('ctx.body: ', ctx.body)
+
+      assert.equal(ctx.body.success, true)
+    })
+
+    it('should catch and throw an error', async () => {
+      try {
+        // Force an error
+        sandbox
+          .stub(uut.bchjs.Transaction, 'get')
+          .rejects(new Error('test error'))
+
+        ctx.request.body = {
+          txid: 'testData'
+        }
+
+        await uut.transaction(ctx)
+      } catch (err) {
+        // console.log('err: ', err)
+        assert.include(err.message, 'test error')
+      }
+    })
+  })
+
+  describe('#handleError', () => {
+    it('should pass an error message', () => {
+      try {
+        const err = {
+          status: 422,
+          message: 'Unprocessable Entity'
+        }
+
+        uut.handleError(ctx, err)
+      } catch (err) {
+        assert.include(err.message, 'Unprocessable Entity')
+      }
+    })
+
+    it('should still throw error if there is no message', () => {
+      try {
+        const err = {
+          status: 404
+        }
+
+        uut.handleError(ctx, err)
+      } catch (err) {
+        assert.include(err.message, 'Not Found')
+      }
+    })
+  })
+})

test/unit/controllers/rest-api/bch/bch.rest.router.unit.js

@@ -1,5 +1,5 @@
 /*
-  Unit tests for the REST API handler for the /fulcrum endpoints.
+  Unit tests for the REST API handler for the /bch endpoints.
 */
 
 // Public npm libraries
@@ -11,19 +11,19 @@ const adapters = require('../../../mocks/adapters')
 const UseCasesMock = require('../../../mocks/use-cases')
 // const app = require('../../../mocks/app-mock')
 
-const FulcrumRouter = require('../../../../../src/controllers/rest-api/fulcrum')
+const BCHRouter = require('../../../../../src/controllers/rest-api/bch')
 let uut
 let sandbox
 // let ctx
 
 // const mockContext = require('../../../../unit/mocks/ctx-mock').context
 
-describe('#Fulcrum-REST-Router', () => {
+describe('#BCH-REST-Router', () => {
   // const testUser = {}
 
   beforeEach(() => {
     const useCases = new UseCasesMock()
-    uut = new FulcrumRouter({ adapters, useCases })
+    uut = new BCHRouter({ adapters, useCases })
 
     sandbox = sinon.createSandbox()
 
@@ -36,26 +36,26 @@ describe('#Fulcrum-REST-Router', () => {
   describe('#constructor', () => {
     it('should throw an error if adapters are not passed in', () => {
       try {
-        uut = new FulcrumRouter()
+        uut = new BCHRouter()
 
         assert.fail('Unexpected code path')
       } catch (err) {
         assert.include(
           err.message,
-          'Instance of Adapters library required when instantiating Fulcrum REST Controller.'
+          'Instance of Adapters library required when instantiating BCH REST Controller.'
         )
       }
     })
 
     it('should throw an error if useCases are not passed in', () => {
       try {
-        uut = new FulcrumRouter({ adapters })
+        uut = new BCHRouter({ adapters })
 
         assert.fail('Unexpected code path')
       } catch (err) {
         assert.include(
           err.message,
-          'Instance of Use Cases library required when instantiating Fulcrum REST Controller.'
+          'Instance of Use Cases library required when instantiating BCH REST Controller.'
         )
       }
     })

test/unit/controllers/rest-api/fulcrum/fulcrum.rest.controller.unit.js

@@ -1,126 +0,0 @@
-/*
-  Unit tests for the REST API handler for the /users endpoints.
-*/
-
-// Public npm libraries
-const assert = require('chai').assert
-const sinon = require('sinon')
-
-// Local support libraries
-const adapters = require('../../../mocks/adapters')
-const UseCasesMock = require('../../../mocks/use-cases')
-// const app = require('../../../mocks/app-mock')
-
-const FulcrumRESTController = require('../../../../../src/controllers/rest-api/fulcrum/controller')
-let uut
-let sandbox
-let ctx
-
-const mockContext = require('../../../../unit/mocks/ctx-mock').context
-
-describe('#Fulcrum-REST-Router', () => {
-  // const testUser = {}
-
-  beforeEach(() => {
-    const useCases = new UseCasesMock()
-    uut = new FulcrumRESTController({ adapters, useCases })
-
-    sandbox = sinon.createSandbox()
-
-    // Mock the context object.
-    ctx = mockContext()
-  })
-
-  afterEach(() => sandbox.restore())
-
-  describe('#constructor', () => {
-    it('should throw an error if adapters are not passed in', () => {
-      try {
-        uut = new FulcrumRESTController()
-
-        assert.fail('Unexpected code path')
-      } catch (err) {
-        assert.include(
-          err.message,
-          'Instance of Adapters library required when instantiating Fulcrum REST Controller.'
-        )
-      }
-    })
-
-    it('should throw an error if useCases are not passed in', () => {
-      try {
-        uut = new FulcrumRESTController({ adapters })
-
-        assert.fail('Unexpected code path')
-      } catch (err) {
-        assert.include(
-          err.message,
-          'Instance of Use Cases library required when instantiating Fulcrum REST Controller.'
-        )
-      }
-    })
-  })
-
-  describe('#transactions', () => {
-    it('should return data from bchjs', async () => {
-      // Mock dependencies
-      sandbox
-        .stub(uut.bchjs.Electrumx, 'transactions')
-        .resolves({ success: true })
-
-      ctx.request.body = {
-        addresses: 'testAddr'
-      }
-
-      await uut.transactions(ctx)
-      // console.log('ctx.body: ', ctx.body)
-
-      assert.equal(ctx.body.success, true)
-    })
-
-    it('should catch and throw an error', async () => {
-      try {
-        // Force an error
-        sandbox
-          .stub(uut.bchjs.Electrumx, 'transactions')
-          .rejects(new Error('test error'))
-
-        ctx.request.body = {
-          addresses: 'testAddr'
-        }
-
-        await uut.transactions(ctx)
-      } catch (err) {
-        // console.log('err: ', err)
-        assert.include(err.message, 'test error')
-      }
-    })
-  })
-
-  describe('#handleError', () => {
-    it('should pass an error message', () => {
-      try {
-        const err = {
-          status: 422,
-          message: 'Unprocessable Entity'
-        }
-
-        uut.handleError(ctx, err)
-      } catch (err) {
-        assert.include(err.message, 'Unprocessable Entity')
-      }
-    })
-
-    it('should still throw error if there is no message', () => {
-      try {
-        const err = {
-          status: 404
-        }
-
-        uut.handleError(ctx, err)
-      } catch (err) {
-        assert.include(err.message, 'Not Found')
-      }
-    })
-  })
-})