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

fix(unit tests): Updating changing test value

docker/mainnet/start-local-mainnet.sh

@@ -17,7 +17,11 @@ export BLOCKBOOK_URL=https://172.17.0.1:9131/
 # Allow node.js to make network calls to https using self-signed certificate.
 export NODE_TLS_REJECT_UNAUTHORIZED=0
 
-# Redis DB
+# Mainnet Fulcrum / ElectrumX
+export FULCRUM_URL=172.17.0.1
+export FULCRUM_PORT=50002
+
+# Redis DB - Used for rate limiting
 export REDIS_PORT=6379
 export REDIS_HOST=172.17.0.1
 

docker/testnet/start-local-testnet.sh

@@ -14,6 +14,10 @@ export BLOCKBOOK_URL=https://172.17.0.1:19131/
 # Allow node.js to make network calls to https using self-signed certificate.
 export NODE_TLS_REJECT_UNAUTHORIZED=0
 
+# Mainnet Fulcrum / ElectrumX
+export FULCRUM_URL=172.17.0.1
+export FULCRUM_PORT=50002
+
 # Redis DB
 export REDIS_PORT=6380
 export REDIS_HOST=172.17.0.1

package.json

@@ -14,21 +14,21 @@
   "scripts": {
     "start": "node ./src/app.js",
     "dev": "nodemon ./dist/app.js",
-    "test": "npm run lint && npm run test-v3",
+    "test": "npm run lint && npm run test-v4",
     "lint": "standard --env mocha --fix",
-    "test-v3": "export NETWORK=mainnet && nyc --reporter=text mocha --timeout 60000 test/v3/",
-    "test:temp": "export NETWORK=mainnet && export TEST=integration && mocha --timeout 25000 test/v3/encryption.js",
-    "test:integration": "mocha test/v3/integration",
-    "test:integration:slpdb": "mocha --timeout 25000 -g '#validate2Single' test/v3/integration/slp*.js",
+    "test-v4": "export NETWORK=mainnet && nyc --reporter=text mocha --timeout 60000 test/v4/",
+    "test:temp": "export NETWORK=mainnet && export TEST=integration && mocha --timeout 25000 test/v4/integration/price.js",
+    "test:integration": "mocha test/v4/integration",
+    "test:integration:slpdb": "mocha --timeout 25000 -g '#validate2Single' test/v4/integration/slp*.js",
     "coverage": "nyc report --reporter=text-lcov | coveralls",
-    "coverage:report": "export NETWORK=mainnet && nyc --reporter=html mocha --timeout 25000 test/v3/",
-    "docs": "./node_modules/.bin/apidoc -i src/routes/v3 -o docs"
+    "coverage:report": "export NETWORK=mainnet && nyc --reporter=html mocha --timeout 25000 test/v4/",
+    "docs": "./node_modules/.bin/apidoc -i src/routes/v4 -o docs"
   },
   "engines": {
     "node": ">=10.15.1"
   },
   "dependencies": {
-    "@psf/bch-js": "^3.7.1",
+    "@psf/bch-js": "^4.0.0",
     "apidoc": "^0.23.0",
     "axios": "^0.19.0",
     "bitcore-lib-cash": "^8.20.3",
@@ -75,7 +75,7 @@
     "proxyquire": "^2.1.0",
     "request": "^2.88.0",
     "request-promise": "^4.2.2",
-    "semantic-release": "^17.0.0",
+    "semantic-release": "^17.3.0",
     "sinon": "^9.0.0",
     "standard": "^14.3.1",
     "typescript": "^3.1.4"
@@ -90,6 +90,6 @@
   },
   "apidoc": {
     "title": "bch-api",
-    "url": "https://api.fullstack.cash/v3"
+    "url": "https://api.fullstack.cash/v4"
   }
 }

src/app.js

@@ -41,9 +41,24 @@ const ElectrumXV3 = require('./routes/v3/electrumx')
 const EncryptionV3 = require('./routes/v3/encryption')
 const PriceV3 = require('./routes/v3/price')
 
+// v4
+const healthCheckV4 = require('./routes/v4/health-check')
+const BlockchainV4 = require('./routes/v4/full-node/blockchain')
+const ControlV4 = require('./routes/v4/full-node/control')
+const MiningV4 = require('./routes/v4/full-node/mining')
+const networkV4 = require('./routes/v4/full-node/network')
+const RawtransactionsV4 = require('./routes/v4/full-node/rawtransactions')
+const utilV4 = require('./routes/v4/util')
+const SlpV4 = require('./routes/v4/slp')
+const xpubV4 = require('./routes/v4/xpub')
+const BlockbookV4 = require('./routes/v4/blockbook')
+const ElectrumXV4 = require('./routes/v4/electrumx')
+const EncryptionV4 = require('./routes/v4/encryption')
+const PriceV4 = require('./routes/v4/price')
+
 require('dotenv').config()
 
-// Instantiate route libraries.
+// Instantiate v3 route libraries.
 const blockchainV3 = new BlockchainV3()
 const controlV3 = new ControlV3()
 const miningV3 = new MiningV3()
@@ -55,6 +70,18 @@ electrumxv3.connect()
 const encryptionv3 = new EncryptionV3()
 const pricev3 = new PriceV3()
 
+// Instantiate v4 route libraries.
+const blockchainV4 = new BlockchainV4()
+const controlV4 = new ControlV4()
+const miningV4 = new MiningV4()
+const rawtransactionsV4 = new RawtransactionsV4()
+const slpV4 = new SlpV4()
+const blockbookV4 = new BlockbookV4()
+const electrumxv4 = new ElectrumXV4()
+electrumxv4.connect()
+const encryptionv4 = new EncryptionV4()
+const pricev4 = new PriceV4()
+
 const app = express()
 
 app.locals.env = process.env
@@ -97,20 +124,28 @@ app.use('/', logReqInfo)
 
 // const v2prefix = "v2"
 const v3prefix = 'v3'
+const v4prefix = 'v4'
 
 // Inspect the header for a JWT token.
 app.use(`/${v3prefix}/`, jwtAuth.getTokenFromHeaders)
+app.use(`/${v4prefix}/`, jwtAuth.getTokenFromHeaders)
 
 // Instantiate the authorization middleware, used to implement pro-tier rate limiting.
 // Handles Anonymous and Basic Authorization schemes used by passport.js
 const auth = new AuthMW()
 app.use(`/${v3prefix}/`, auth.mw())
+app.use(`/${v4prefix}/`, auth.mw())
 
 // Rate limit on all v3 routes
 // Establish and enforce rate limits.
 // app.use(`/${v3prefix}/`, rateLimits.routeRateLimit)
 app.use(`/${v3prefix}/`, rateLimits.rateLimitByResource)
 
+// Rate limit on all v4 routes
+// Establish and enforce rate limits.
+app.use(`/${v4prefix}/`, rateLimits.rateLimitByResource)
+
+// Connect v3 routes
 app.use(`/${v3prefix}/` + 'health-check', healthCheckV3)
 app.use(`/${v3prefix}/` + 'blockchain', blockchainV3.router)
 app.use(`/${v3prefix}/` + 'control', controlV3.router)
@@ -125,8 +160,24 @@ app.use(`/${v3prefix}/` + 'electrumx', electrumxv3.router)
 app.use(`/${v3prefix}/` + 'encryption', encryptionv3.router)
 app.use(`/${v3prefix}/` + 'price', pricev3.router)
 
+// Connect v4 routes
+app.use(`/${v4prefix}/` + 'health-check', healthCheckV4)
+app.use(`/${v4prefix}/` + 'blockchain', blockchainV4.router)
+app.use(`/${v4prefix}/` + 'control', controlV4.router)
+app.use(`/${v4prefix}/` + 'mining', miningV4.router)
+app.use(`/${v4prefix}/` + 'network', networkV4)
+app.use(`/${v4prefix}/` + 'rawtransactions', rawtransactionsV4.router)
+app.use(`/${v4prefix}/` + 'util', utilV4.router)
+app.use(`/${v4prefix}/` + 'slp', slpV4.router)
+app.use(`/${v4prefix}/` + 'xpub', xpubV4.router)
+app.use(`/${v4prefix}/` + 'blockbook', blockbookV4.router)
+app.use(`/${v4prefix}/` + 'electrumx', electrumxv4.router)
+app.use(`/${v4prefix}/` + 'encryption', encryptionv4.router)
+app.use(`/${v4prefix}/` + 'price', pricev4.router)
+
 const ninsight = new Ninsight()
 app.use(`/${v3prefix}/` + 'ninsight', ninsight.router)
+app.use(`/${v4prefix}/` + 'ninsight', ninsight.router)
 
 // catch 404 and forward to error handler
 app.use((req, res, next) => {

src/middleware/auth.js

@@ -33,7 +33,9 @@ util.inspect.defaultOptions = { depth: 1 }
 // let _this
 
 // Set default rate limit value for testing
-const PRO_PASSES = process.env.PRO_PASSES ? process.env.PRO_PASSES : 'testpassword'
+const PRO_PASSES = process.env.PRO_PASS
+  ? process.env.PRO_PASS
+  : 'testpassword'
 // Convert the pro-tier password string into an array split by ':'.
 const PRO_PASS = PRO_PASSES.split(':')
 
@@ -47,6 +49,8 @@ class AuthMW {
     // Initialize passport for 'anonymous' authentication.
     passport.use(new AnonymousStrategy())
 
+    console.log(`PRO_PASS: ${JSON.stringify(PRO_PASS, null, 2)}`)
+
     // Initialize passport for 'basic' authentication.
     passport.use(
       new BasicStrategy({ passReqToCallback: true }, function (

src/middleware/route-ratelimit.js

@@ -12,10 +12,12 @@
 
 'use strict'
 
+const jwt = require('jsonwebtoken')
+
 const wlogger = require('../util/winston-logging')
 const config = require('../../config')
 
-const jwt = require('jsonwebtoken')
+const ANON_LIMITS = 50
 
 // Redis
 const redisOptions = {
@@ -111,7 +113,7 @@ class RateLimits {
       }
 
       // Default value is 50 points per request = 20 RPM
-      let rateLimit = 50
+      let rateLimit = ANON_LIMITS
 
       // Only evaluate the JWT token if the user is not using Basic Authentication.
       if (!req.locals.proLimit) {
@@ -144,9 +146,9 @@ class RateLimits {
           // apply paid-access rate limits.
           if (
             origin &&
-            (origin.toString().indexOf('wallet.fullstack.cash') > -1 ||
-              origin.toString().indexOf('sandbox.fullstack.cash') > -1 ||
-              origin === 'slp-api')
+            (origin.toString().indexOf('fullstack.cash') > -1 ||
+              origin.toString().indexOf('splitbch.com') > -1 ||
+              origin.toString().indexOf('slp-api') > -1)
           ) {
             pointsToConsume = 10
             res.locals.pointsToConsume = pointsToConsume // Feedback for tests.
@@ -154,9 +156,10 @@ class RateLimits {
 
           // For internal calls, increase rate limits to as fast as possible.
           if (
-            key.toString().indexOf('172.17.') > -1
             // Comment out the line below when running bch-js e2e rate limit tests.
-            // key.toString().indexOf('::ffff:127.0.0.1') > -1
+            key.toString().indexOf('::ffff:127.0.0.1') > -1 ||
+            // Do not comment out this line.
+            key.toString().indexOf('172.17.') > -1
           ) {
             pointsToConsume = 1
             res.locals.pointsToConsume = pointsToConsume // Feedback for tests.
@@ -197,7 +200,7 @@ class RateLimits {
   // Calculates the points consumed, based on the jwt information and the route
   // requested.
   calcPoints (jwtInfo) {
-    let retVal = 50 // By default, use anonymous tier.
+    let retVal = ANON_LIMITS // By default, use anonymous tier.
 
     try {
       // console.log(`jwtInfo: ${JSON.stringify(jwtInfo, null, 2)}`)
@@ -216,12 +219,12 @@ class RateLimits {
         if (level40Routes.includes(resource)) {
           if (apiLevel >= 40) retVal = 10
           // else if (apiLevel >= 10) retVal = 10
-          else retVal = 50
+          else retVal = ANON_LIMITS
 
           // Normal indexer routes
         } else if (level30Routes.includes(resource)) {
           if (apiLevel >= 30) retVal = 10
-          else retVal = 50
+          else retVal = ANON_LIMITS
 
           // Full node tier
         } else if (apiLevel >= 20) {
@@ -229,7 +232,7 @@ class RateLimits {
 
           // Free tier, full node only.
         } else {
-          retVal = 50
+          retVal = ANON_LIMITS
         }
       }
 
@@ -237,7 +240,7 @@ class RateLimits {
     } catch (err) {
       wlogger.error('Error in route-ratelimit.js/calcPoints()')
       // throw err
-      retVal = 50
+      retVal = ANON_LIMITS
     }
 
     return retVal

src/routes/v3/electrumx.js

@@ -79,6 +79,21 @@ class Electrum {
       // Set the connection flag.
       _this.isReady = true
 
+      // Periodically check the connection. If it's not connected, attempt to
+      // reconnect.
+      _this.reconnectIntervalHandle = setInterval(async function () {
+        const status = _this.electrumx.connection.status
+        // console.log(`Electrumx status: ${status}`)
+
+        // 1 = connected. If we're not connected, attemp to reconnect.
+        if (status !== 1) {
+          wlogger.info(`Electrumx not connectes. Status: ${status}`)
+          wlogger.info('Attempting to reconnect...')
+          await _this.electrumx.connect()
+          wlogger.info('...reconnected.')
+        }
+      }, 30000)
+
       console.log('...Successfully connected to ElectrumX server.')
 
       // console.log(`_this.isReady: ${_this.isReady}`)
@@ -96,6 +111,9 @@ class Electrum {
       // Return immediately if the isReady flag is false.
       if (!_this.isReady) return true
 
+      // Disable the reconnect timer.
+      clearInterval(_this.reconnectIntervalHandle)
+
       // Disconnect from the server.
       await _this.electrumx.disconnect()
 

src/routes/v3/price.js

@@ -24,11 +24,14 @@ class Price {
     this.routeUtils = routeUtils
 
     this.priceUrl = 'https://api.coinbase.com/v2/exchange-rates?currency=BCH'
+    this.coinexPriceUrl =
+      'https://api.coinex.com/v1/market/ticker?market=bchausdt'
 
     this.router = express.Router()
     this.router.get('/', _this.root)
     this.router.get('/usd', _this.getUSD)
     this.router.get('/rates', _this.getBCHRate)
+    this.router.get('/bchausd', _this.getBCHAUSD)
   }
 
   // DRY error handler.
@@ -53,7 +56,7 @@ class Price {
    * @api {get} /price/usd Get the USD price of BCH
    * @apiName Get the USD price of BCH
    * @apiGroup Price
-   * @apiDescription Get the USD price of BCH
+   * @apiDescription Get the USD price of BCH from Coinbase.
    *
    *
    * @apiExample Example usage:
@@ -85,7 +88,7 @@ class Price {
    * @api {get} /price/usd Get rates for several different currencies
    * @apiName Get rates for several different currencies
    * @apiGroup Price
-   * @apiDescription Get rates for several different currencies
+   * @apiDescription Get rates for several different currencies from Coinbase.
    *
    *
    * @apiExample Example usage:
@@ -113,6 +116,40 @@ class Price {
       return _this.errorHandler(err, res)
     }
   }
+
+  /**
+   * @api {get} /price/bchausd Get the USD price of BCHA
+   * @apiName Get the USD price of BCHA
+   * @apiGroup Price
+   * @apiDescription Get the USD price of BCHA from Coinex.
+   *
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v3/price/bchausd" -H "accept: application/json"
+   *
+   */
+  async getBCHAUSD (req, res, next) {
+    try {
+      // Request options
+      const opt = {
+        method: 'get',
+        baseURL: _this.coinexPriceUrl,
+        timeout: 15000
+      }
+
+      const response = await axios.request(opt)
+      // console.log(`response.data: ${JSON.stringify(response.data, null, 2)}`)
+
+      const price = Number(response.data.data.ticker.last)
+
+      return res.json({ usd: price })
+    } catch (err) {
+      // Write out error to error log.
+      wlogger.error('Error in price.js/getBCHAUSD().', err)
+
+      return _this.errorHandler(err, res)
+    }
+  }
 }
 
 module.exports = Price

src/routes/v3/slp.js

@@ -1251,7 +1251,9 @@ class Slp {
       const tokenRes = await _this.axios.request(opt)
       // console.log(`tokenRes: ${util.inspect(tokenRes)}`)
 
-      if (tokenRes.data.c.length === 0) {
+      // Return 'not found' error if both the confirmed and unconfirmed
+      // collections are empty.
+      if (tokenRes.data.c.length === 0 && tokenRes.data.u.length === 0) {
         res.status(404)
         return res.json({ error: 'TXID not found' })
       }
@@ -1437,12 +1439,29 @@ class Slp {
       sendOutputs.push(string.toString())
     })
 
+    // Because you are not using Insight API indexer, you do not get the
+    // sending addresses from an indexer or from the node.
+    // However, they are available from the SLPDB output.
+    const tokenInputs = transaction.in
+    // Collect the input addresses
+    const sendInputs = []
+    for (let i = 0; i < tokenInputs.length; i += 1) {
+      const tokenInput = tokenInputs[i]
+      const sendInput = {}
+      sendInput.address = tokenInput.e.a
+      sendInputs.push(sendInput)
+    }
+
     const obj = {
       tokenInfo: {
         versionType: transaction.slp.detail.versionType,
+        tokenName: transaction.slp.detail.name,
+        tokenTicker: transaction.slp.detail.symbol,
         transactionType: transaction.slp.detail.transactionType,
         tokenIdHex: transaction.slp.detail.tokenIdHex,
-        sendOutputs: sendOutputs
+        sendOutputs: sendOutputs,
+        sendInputsFull: sendInputs,
+        sendOutputsFull: transaction.slp.detail.outputs
       },
       tokenIsValid: transaction.slp.valid
     }

src/routes/v4/blockbook.js

@@ -0,0 +1,521 @@
+/*
+  Blockbook API route
+*/
+
+'use strict'
+
+const express = require('express')
+const axios = require('axios')
+const wlogger = require('../../util/winston-logging')
+
+const RouteUtils = require('../../util/route-utils')
+const routeUtils = new RouteUtils()
+
+// Library for easily switching the API paths to use different instances of
+// Blockbook.
+const BlockbookPath = require('../../util/blockbook-path')
+const BLOCKBOOKPATH = new BlockbookPath()
+// BLOCKBOOKPATH.toOpenBazaar()
+
+const router = express.Router()
+
+// Used for processing error messages before sending them to the user.
+const util = require('util')
+util.inspect.defaultOptions = { depth: 1 }
+
+const BCHJS = require('@psf/bch-js')
+const bchjs = new BCHJS()
+
+let _this
+
+class Blockbook {
+  constructor () {
+    _this = this
+
+    _this.axios = axios
+    _this.routeUtils = routeUtils
+    _this.bchjs = bchjs
+    _this.BLOCKBOOKPATH = BLOCKBOOKPATH
+
+    _this.router = router
+    _this.router.get('/', _this.root)
+    _this.router.get('/balance/:address', _this.balanceSingle)
+    _this.router.post('/balance', _this.balanceBulk)
+    _this.router.get('/utxos/:address', _this.utxosSingle)
+    _this.router.post('/utxos', _this.utxosBulk)
+    _this.router.get('/tx/:txid', _this.txSingle)
+    _this.router.post('/tx', _this.txBulk)
+  }
+
+  // DRY error handler.
+  errorHandler (err, res) {
+    // Attempt to decode the error message.
+    const { msg, status } = _this.routeUtils.decodeError(err)
+    if (msg) {
+      res.status(status)
+      return res.json({ error: msg })
+    }
+
+    res.status(500)
+    return res.json({ error: util.inspect(err) })
+  }
+
+  // Root API endpoint. Simply acknowledges that it exists.
+  root (req, res, next) {
+    return res.json({ status: 'address' })
+  }
+
+  // Query the Blockbook Node API for a balance on a single BCH address.
+  // Returns a Promise.
+  async balanceFromBlockbook (thisAddress) {
+    try {
+      // console.log(`BLOCKBOOK_URL: ${BLOCKBOOK_URL}`)
+
+      // Convert the address to a cashaddr without a prefix.
+      const addr = _this.bchjs.Address.toCashAddress(thisAddress)
+
+      const path = `${_this.BLOCKBOOKPATH.addrPath}${addr}`
+      // console.log(`path: ${path}`)
+
+      // Query the Blockbook Node API.
+      const options = {
+        method: 'get',
+        baseURL: path
+      }
+
+      const axiosResponse = await _this.axios.request(options)
+      const retData = axiosResponse.data
+      // console.log(`retData: ${util.inspect(retData)}`)
+
+      return retData
+    } catch (err) {
+      // Dev Note: Do not log error messages here. Throw them instead and let the
+      // parent function handle it.
+      wlogger.debug('Error in blockbook.js/balanceFromBlockbook()')
+      throw err
+    }
+  }
+
+  async balanceSingle (req, res, next) {
+    try {
+      const address = req.params.address
+
+      if (!address || address === '') {
+        res.status(400)
+        return res.json({ error: 'address can not be empty' })
+      }
+
+      // Reject if address is an array.
+      if (Array.isArray(address)) {
+        res.status(400)
+        return res.json({
+          error: 'address can not be an array. Use POST for bulk upload.'
+        })
+      }
+
+      wlogger.debug(
+        'Executing blockbook/balanceSingle with this address: ',
+        address
+      )
+
+      // Ensure the input is a valid BCH address.
+      try {
+        // const legacyAddr = bchjs.Address.toLegacyAddress(address)
+        _this.bchjs.Address.toLegacyAddress(address)
+      } catch (err) {
+        res.status(400)
+        return res.json({
+          error: `Invalid BCH address. Double check your address is valid: ${address}`
+        })
+      }
+
+      // Prevent a common user error. Ensure they are using the correct network address.
+      const networkIsValid = _this.routeUtils.validateNetwork(address)
+      if (!networkIsValid) {
+        res.status(400)
+        return res.json({
+          error:
+            'Invalid network. Trying to use a testnet address on mainnet, or vice versa.'
+        })
+      }
+
+      // Query the Blockbook Node API.
+      const retData = await _this.balanceFromBlockbook(address)
+
+      // Return the retrieved address information.
+      res.status(200)
+      return res.json(retData)
+    } catch (err) {
+      // Write out error to error log.
+      wlogger.error('Error in blockbook.js/balanceSingle().', err)
+
+      return _this.errorHandler(err, res)
+    }
+  }
+
+  // POST handler for bulk queries on address details
+  async balanceBulk (req, res, next) {
+    try {
+      let addresses = req.body.addresses
+      // const currentPage = req.body.page ? parseInt(req.body.page, 10) : 0
+
+      // Reject if addresses is not an array.
+      if (!Array.isArray(addresses)) {
+        res.status(400)
+        return res.json({
+          error: 'addresses needs to be an array. Use GET for single address.'
+        })
+      }
+
+      // Enforce array size rate limits
+      if (!_this.routeUtils.validateArraySize(req, addresses)) {
+        res.status(429) // https://github.com/Bitcoin-com/rest.bitcoin.com/issues/330
+        return res.json({
+          error: 'Array too large.'
+        })
+      }
+
+      wlogger.debug(
+        'Executing blockbook.js/balanceBulk with these addresses: ',
+        addresses
+      )
+
+      // Validate each element in the address array.
+      for (let i = 0; i < addresses.length; i++) {
+        const thisAddress = addresses[i]
+
+        // Ensure the input is a valid BCH address.
+        try {
+          _this.bchjs.Address.toLegacyAddress(thisAddress)
+        } catch (err) {
+          res.status(400)
+          return res.json({
+            error: `Invalid BCH address. Double check your address is valid: ${thisAddress}`
+          })
+        }
+
+        // Prevent a common user error. Ensure they are using the correct network address.
+        const networkIsValid = _this.routeUtils.validateNetwork(thisAddress)
+        if (!networkIsValid) {
+          res.status(400)
+          return res.json({
+            error: `Invalid network for address ${thisAddress}. Trying to use a testnet address on mainnet, or vice versa.`
+          })
+        }
+      }
+
+      // Loops through each address and creates an array of Promises, querying
+      // Insight API in parallel.
+      addresses = addresses.map(async (address, index) =>
+        // console.log(`address: ${address}`)
+        _this.balanceFromBlockbook(address)
+      )
+
+      // Wait for all parallel Insight requests to return.
+      const result = await _this.axios.all(addresses)
+
+      // Return the array of retrieved address information.
+      res.status(200)
+      return res.json(result)
+    } catch (err) {
+      wlogger.error('Error in blockbook.js/balanceBulk().', err)
+
+      return _this.errorHandler(err, res)
+    }
+  }
+
+  // Query the Blockbook API for utxos associated with a BCH address.
+  // Returns a Promise.
+  async utxosFromBlockbook (thisAddress) {
+    try {
+      // console.log(`BLOCKBOOK_URL: ${BLOCKBOOK_URL}`)
+
+      // Convert the address to a cashaddr without a prefix.
+      const addr = _this.bchjs.Address.toCashAddress(thisAddress)
+
+      const path = `${_this.BLOCKBOOKPATH.utxoPath}${addr}`
+      // console.log(`path: ${path}`)
+
+      // Query the Blockbook API.
+      // Query the Blockbook Node API.
+      const options = {
+        method: 'get',
+        baseURL: path
+      }
+      const axiosResponse = await _this.axios.request(options)
+      const retData = axiosResponse.data
+      // console.log(`retData: ${util.inspect(retData)}`)
+
+      // Add the satoshis property to each UTXO.
+      for (let i = 0; i < retData.length; i++) {
+        retData[i].satoshis = Number(retData[i].value)
+      }
+
+      return retData
+    } catch (err) {
+      // Dev Note: Do not log error messages here. Throw them instead and let the
+      // parent function handle it.
+      wlogger.debug('Error in blockbook.js/utxosFromBlockbook()')
+      throw err
+    }
+  }
+
+  // GET handler for single balance
+  async utxosSingle (req, res, next) {
+    try {
+      const address = req.params.address
+
+      if (!address || address === '') {
+        res.status(400)
+        return res.json({ error: 'address can not be empty' })
+      }
+
+      // Reject if address is an array.
+      if (Array.isArray(address)) {
+        res.status(400)
+        return res.json({
+          error: 'address can not be an array. Use POST for bulk upload.'
+        })
+      }
+
+      wlogger.debug(
+        'Executing blockbook/utxosSingle with this address: ',
+        address
+      )
+
+      // Ensure the input is a valid BCH address.
+      try {
+        // const legacyAddr = bchjs.Address.toLegacyAddress(address)
+        _this.bchjs.Address.toLegacyAddress(address)
+      } catch (err) {
+        res.status(400)
+        return res.json({
+          error: `Invalid BCH address. Double check your address is valid: ${address}`
+        })
+      }
+
+      // Prevent a common user error. Ensure they are using the correct network address.
+      const networkIsValid = _this.routeUtils.validateNetwork(address)
+      if (!networkIsValid) {
+        res.status(400)
+        return res.json({
+          error:
+            'Invalid network. Trying to use a testnet address on mainnet, or vice versa.'
+        })
+      }
+
+      // Query the Blockbook API.
+      const retData = await _this.utxosFromBlockbook(address)
+
+      // Return the retrieved address information.
+      res.status(200)
+      return res.json(retData)
+    } catch (err) {
+      // Write out error to error log.
+      wlogger.error('Error in blockbook.js/utxosSingle().', err)
+      return _this.errorHandler(err, res)
+    }
+  }
+
+  // POST handler for bulk queries on address utxos
+  async utxosBulk (req, res, next) {
+    try {
+      let addresses = req.body.addresses
+      // const currentPage = req.body.page ? parseInt(req.body.page, 10) : 0
+
+      // Reject if addresses is not an array.
+      if (!Array.isArray(addresses)) {
+        res.status(400)
+        return res.json({
+          error: 'addresses needs to be an array. Use GET for single address.'
+        })
+      }
+
+      // Enforce array size rate limits
+      if (!_this.routeUtils.validateArraySize(req, addresses)) {
+        res.status(429) // https://github.com/Bitcoin-com/rest.bitcoin.com/issues/330
+        return res.json({
+          error: 'Array too large.'
+        })
+      }
+
+      wlogger.debug(
+        'Executing blockbook.js/utxosBulk with these addresses: ',
+        addresses
+      )
+
+      // Validate each element in the address array.
+      for (let i = 0; i < addresses.length; i++) {
+        const thisAddress = addresses[i]
+
+        // Ensure the input is a valid BCH address.
+        try {
+          _this.bchjs.Address.toLegacyAddress(thisAddress)
+        } catch (err) {
+          res.status(400)
+          return res.json({
+            error: `Invalid BCH address. Double check your address is valid: ${thisAddress}`
+          })
+        }
+
+        // Prevent a common user error. Ensure they are using the correct network address.
+        const networkIsValid = _this.routeUtils.validateNetwork(thisAddress)
+        if (!networkIsValid) {
+          res.status(400)
+          return res.json({
+            error: `Invalid network for address ${thisAddress}. Trying to use a testnet address on mainnet, or vice versa.`
+          })
+        }
+      }
+
+      // Loops through each address and creates an array of Promises, querying
+      // Insight API in parallel.
+      addresses = addresses.map(async (address, index) =>
+        // console.log(`address: ${address}`)
+        _this.utxosFromBlockbook(address)
+      )
+
+      // Wait for all parallel Insight requests to return.
+      const result = await _this.axios.all(addresses)
+
+      // Return the array of retrieved address information.
+      res.status(200)
+      return res.json(result)
+    } catch (err) {
+      wlogger.error('Error in blockbook.js/utxosBulk().', err)
+      return _this.errorHandler(err, res)
+    }
+  }
+
+  // Query the Blockbook Node API for transactions on a single TXID.
+  // Returns a Promise.
+  async transactionsFromBlockbook (txid) {
+    try {
+      // console.log(`BLOCKBOOK_URL: ${BLOCKBOOK_URL}`)
+
+      const path = `${_this.BLOCKBOOKPATH.txPath}${txid}`
+      // console.log(`path: ${path}`)
+
+      // Query the Blockbook Node API.
+      const options = {
+        method: 'get',
+        baseURL: path
+      }
+      const axiosResponse = await _this.axios.request(options)
+      const retPromise = axiosResponse.data
+      // console.log(`retData: ${util.inspect(retData)}`)
+
+      return retPromise
+    } catch (err) {
+      // Dev Note: Do not log error messages here. Throw them instead and let the
+      // parent function handle it.
+      wlogger.debug('Error in blockbook.js/transactionsFromBlockbook()')
+      throw err
+    }
+  }
+
+  // GET handler for single transaction details.
+  async txSingle (req, res, next) {
+    try {
+      const txid = req.params.txid
+
+      if (!txid || txid === '') {
+        res.status(400)
+        return res.json({ error: 'txid can not be empty' })
+      }
+
+      // Reject if address is an array.
+      if (Array.isArray(txid)) {
+        res.status(400)
+        return res.json({
+          error: 'txid can not be an array. Use POST for bulk upload.'
+        })
+      }
+
+      // TODO: Add regex comparison of txid to ensure it's valid.
+      if (txid.length !== 64) {
+        res.status(400)
+        return res.json({
+          error: `txid must be of length 64 (not ${txid.length})`
+        })
+      }
+
+      wlogger.debug('Executing blockbook/txSingle with this txid: ', txid)
+
+      // Query the Blockbook Node API.
+      const retData = await _this.transactionsFromBlockbook(txid)
+
+      // Return the retrieved address information.
+      res.status(200)
+      return res.json(retData)
+    } catch (err) {
+      // Write out error to error log.
+      wlogger.error('Error in blockbook.js/txSingle().', err)
+
+      return _this.errorHandler(err, res)
+    }
+  }
+
+  // POST handler for bulk queries on tx details
+  async txBulk (req, res, next) {
+    try {
+      let txids = req.body.txids
+      // const currentPage = req.body.page ? parseInt(req.body.page, 10) : 0
+
+      // Reject if txids is not an array.
+      if (!Array.isArray(txids)) {
+        res.status(400)
+        return res.json({
+          error: 'txids need to be an array. Use GET for single address.'
+        })
+      }
+
+      // Enforce array size rate limits
+      if (!_this.routeUtils.validateArraySize(req, txids)) {
+        res.status(429) // https://github.com/Bitcoin-com/rest.bitcoin.com/issues/330
+        return res.json({
+          error: 'Array too large.'
+        })
+      }
+
+      wlogger.debug('Executing blockbook.js/txBulk with these txids: ', txids)
+
+      // Validate each element in the txids array.
+      for (let i = 0; i < txids.length; i++) {
+        const thisTxid = txids[i]
+
+        if (!thisTxid || thisTxid === '') {
+          res.status(400)
+          return res.json({ error: 'txid can not be empty' })
+        }
+
+        // TODO: Add regex comparison of txid to ensure it's valid.
+        if (thisTxid.length !== 64) {
+          res.status(400)
+          return res.json({
+            error: `txid must be of length 64 (not ${thisTxid.length})`
+          })
+        }
+      }
+
+      // Loops through each address and creates an array of Promises, querying
+      // Insight API in parallel.
+      txids = txids.map(async (txid, index) =>
+        // console.log(`address: ${address}`)
+        _this.transactionsFromBlockbook(txid)
+      )
+
+      // Wait for all parallel Insight requests to return.
+      const result = await _this.axios.all(txids)
+
+      // Return the array of retrieved address information.
+      res.status(200)
+      return res.json(result)
+    } catch (err) {
+      wlogger.error('Error in blockbook.js/txBulk().', err)
+      return _this.errorHandler(err, res)
+    }
+  }
+}
+
+module.exports = Blockbook

src/routes/v4/encryption.js

@@ -0,0 +1,180 @@
+/*
+  Encryption API route
+*/
+
+'use strict'
+
+const express = require('express')
+const router = express.Router()
+const axios = require('axios')
+const util = require('util')
+
+const wlogger = require('../../util/winston-logging')
+const config = require('../../../config')
+
+const RouteUtils = require('../../util/route-utils')
+const routeUtils = new RouteUtils()
+
+const BCHJS = require('@psf/bch-js')
+const restURL = process.env.LOCAL_RESTURL
+  ? process.env.LOCAL_RESTURL
+  : 'https://api.fullstack.cash/v4/'
+const bchjs = new BCHJS({ restURL })
+
+let _this
+
+class Encryption {
+  constructor () {
+    _this = this
+
+    _this.config = config
+    _this.axios = axios
+    _this.routeUtils = routeUtils
+    _this.bchjs = bchjs
+    // _this.blockbook = blockbook
+    // _this.rawTransactions = rawTransactions
+
+    _this.router = router
+    _this.router.get('/', _this.root)
+    _this.router.get('/publickey/:address', _this.getPublicKey)
+  }
+
+  // DRY error handler.
+  errorHandler (err, res) {
+    // Attempt to decode the error message.
+    const { msg, status } = _this.routeUtils.decodeError(err)
+    if (msg) {
+      res.status(status)
+      return res.json({ error: msg })
+    }
+
+    // Handle error patterns specific to this route.
+    if (err.message) {
+      res.status(400)
+      return res.json({ success: false, error: err.message })
+    }
+
+    wlogger.error('Unhandled error in Encryption library: ', err)
+
+    // If error can be handled, return the stack trace
+    res.status(500)
+    return res.json({ error: util.inspect(err) })
+  }
+
+  // Root API endpoint. Simply acknowledges that it exists.
+  root (req, res, next) {
+    return res.json({ status: 'encryption' })
+  }
+
+  /**
+   * @api {get} /encryption/publickey/{addr} Get public key for a BCH address.
+   * @apiName Get encryption key for bch address
+   * @apiGroup Encryption
+   * @apiDescription Searches the blockchain for a public key associated with a
+   * BCH address. Returns an object. If successful, the publicKey property will
+   * contain a hexidecimal representation of the public key.
+   *
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v4/encryption/publickey/bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf" -H "accept: application/json"
+   *
+   */
+  async getPublicKey (req, res, next) {
+    try {
+      const address = req.params.address
+
+      // Reject if address is an array.
+      if (Array.isArray(address)) {
+        res.status(400)
+        return res.json({
+          success: false,
+          error: 'address can not be an array.'
+        })
+      }
+
+      const cashAddr = _this.bchjs.Address.toCashAddress(address)
+
+      // Prevent a common user error. Ensure they are using the correct network address.
+      const networkIsValid = _this.routeUtils.validateNetwork(cashAddr)
+      if (!networkIsValid) {
+        res.status(400)
+        return res.json({
+          success: false,
+          error:
+            'Invalid network. Trying to use a testnet address on mainnet, or vice versa.'
+        })
+      }
+
+      wlogger.debug(
+        'Executing encryption/getPublicKey with this address: ',
+        cashAddr
+      )
+
+      const rawTxData = await _this.bchjs.Electrumx.transactions(cashAddr)
+      // console.log(`rawTxData: ${JSON.stringify(rawTxData, null, 2)}`)
+
+      // Extract just the TXIDs
+      const txids = rawTxData.transactions.map((elem) => elem.tx_hash)
+      // console.log(`txids: ${JSON.stringify(txids, null, 2)}`)
+
+      // throw error if there is no transaction history.
+      if (!txids || txids.length === 0) {
+        throw new Error('No transaction history.')
+      }
+
+      // Loop through the transaction history and search for the public key.
+      for (let i = 0; i < txids.length; i++) {
+        const thisTx = txids[i]
+
+        const txDetails = await _this.bchjs.RawTransactions.getRawTransaction(
+          thisTx,
+          true
+        )
+        // console.log(`txDetails: ${JSON.stringify(txDetails, null, 2)}`)
+
+        const vin = txDetails.vin
+
+        // Loop through each input.
+        for (let j = 0; j < vin.length; j++) {
+          const thisVin = vin[j]
+          // console.log(`thisVin: ${JSON.stringify(thisVin, null, 2)}`)
+
+          // Extract the script signature.
+          const scriptSig = thisVin.scriptSig.asm.split(' ')
+          // console.log(`scriptSig: ${JSON.stringify(scriptSig, null, 2)}`)
+
+          // Extract the public key from the script signature.
+          const pubKey = scriptSig[scriptSig.length - 1]
+          // console.log(`pubKey: ${pubKey}`)
+
+          // Generate cash address from public key.
+          const keyBuf = Buffer.from(pubKey, 'hex')
+          const ec = _this.bchjs.ECPair.fromPublicKey(keyBuf)
+          const cashAddr2 = _this.bchjs.ECPair.toCashAddress(ec)
+          // console.log(`cashAddr2: ${cashAddr2}`)
+
+          // If public keys match, this is the correct public key.
+          if (cashAddr === cashAddr2) {
+            res.status(200)
+            return res.json({
+              success: true,
+              publicKey: pubKey
+            })
+          }
+        }
+      }
+
+      res.status(200)
+      return res.json({
+        success: false,
+        publicKey: 'not found'
+      })
+    } catch (err) {
+      wlogger.error('Error in encryption.js/getPublicKey().', err)
+
+      return _this.errorHandler(err, res)
+    }
+  }
+}
+
+module.exports = Encryption

src/routes/v4/full-node/blockchain.js

@@ -0,0 +1,942 @@
+/*
+  A library for interacting with the Full Node
+*/
+
+'use strict'
+
+const express = require('express')
+const router = express.Router()
+
+const axios = require('axios')
+const wlogger = require('../../../util/winston-logging')
+
+const RouteUtils = require('../../../util/route-utils')
+const routeUtils = new RouteUtils()
+
+// Used to convert error messages to strings, to safely pass to users.
+const util = require('util')
+util.inspect.defaultOptions = { depth: 1 }
+
+const BCHJS = require('@psf/bch-js')
+const bchjs = new BCHJS()
+
+let _this
+
+class Blockchain {
+  constructor () {
+    _this = this
+
+    this.bchjs = bchjs
+    this.axios = axios
+    this.routeUtils = routeUtils
+
+    this.router = router
+    this.router.get('/', this.root)
+    this.router.get('/getBestBlockHash', this.getBestBlockHash)
+    this.router.get('/getBlockchainInfo', this.getBlockchainInfo)
+    this.router.get('/getBlockCount', this.getBlockCount)
+    this.router.get('/getBlockHeader/:hash', this.getBlockHeaderSingle)
+    this.router.post('/getBlockHeader', this.getBlockHeaderBulk)
+    this.router.get('/getChainTips', this.getChainTips)
+    this.router.get('/getDifficulty', this.getDifficulty)
+    this.router.get('/getMempoolEntry/:txid', this.getMempoolEntrySingle)
+    this.router.post('/getMempoolEntry', this.getMempoolEntryBulk)
+    this.router.get(
+      '/getMempoolAncestors/:txid',
+      this.getMempoolAncestorsSingle
+    )
+    this.router.get('/getMempoolInfo', this.getMempoolInfo)
+    this.router.get('/getRawMempool', this.getRawMempool)
+    this.router.get('/getTxOut/:txid/:n', this.getTxOut)
+    this.router.post('/getTxOut', this.getTxOutPost)
+    this.router.get('/getTxOutProof/:txid', this.getTxOutProofSingle)
+    this.router.post('/getTxOutProof', this.getTxOutProofBulk)
+    this.router.get('/verifyTxOutProof/:proof', this.verifyTxOutProofSingle)
+    this.router.post('/verifyTxOutProof', this.verifyTxOutProofBulk)
+  }
+
+  root (req, res, next) {
+    return res.json({ status: 'blockchain' })
+  }
+
+  // DRY error handler.
+  errorHandler (err, res) {
+    // Attempt to decode the error message.
+    const { msg, status } = _this.routeUtils.decodeError(err)
+    if (msg) {
+      res.status(status)
+      return res.json({ error: msg })
+    }
+
+    res.status(500)
+    return res.json({ error: util.inspect(err) })
+  }
+
+  /**
+   * @api {get} /blockchain/getBestBlockHash Get best block hash
+   * @apiName GetBestBlockHash
+   * @apiGroup Blockchain
+   * @apiDescription Returns the hash of the best (tip) block in the longest
+   * block chain.
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v4/blockchain/getBestBlockHash" -H "accept: application/json"
+   *
+   * @apiSuccess {String}   bestBlockHash           000000000000000002bc884334336d99c9a9c616670a9244c6a8c1fc35aa91a1
+   */
+  async getBestBlockHash (req, res, next) {
+    try {
+      // Axios options
+      const options = _this.routeUtils.getAxiosOptions()
+      options.data.id = 'getbestblockhash'
+      options.data.method = 'getbestblockhash'
+      options.data.params = []
+
+      const response = await _this.axios.request(options)
+      // console.log(`response.data: ${JSON.stringify(response.data, null, 2)}`)
+
+      return res.json(response.data.result)
+    } catch (err) {
+      // Write out error to error log.
+      wlogger.error('Error in blockchain.ts/getBestBlockHash().', err)
+
+      return _this.errorHandler(err, res)
+    }
+  }
+
+  /**
+   * @api {get} /blockchain/getBlockchainInfo Get blockchain info
+   * @apiName GetBlockchainInfo
+   * @apiGroup Blockchain
+   * @apiDescription Returns an object containing various state info regarding blockchain processing.
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v4/blockchain/getBlockchainInfo" -H "accept: application/json"
+   *
+   * @apiSuccess {Object}   object                      Object containing data
+   * @apiSuccess {String}   object.chain                "main"
+   * @apiSuccess {Number}   object.blocks               561838
+   * @apiSuccess {Number}   object.headers              561838
+   * @apiSuccess {String}   object.bestblockhash        "000000000000000002307dd38cd01c7308b8febfcdf5772cf087b5bb023d55bc"
+   * @apiSuccess {Number}   object.difficulty           246585566638.1496
+   * @apiSuccess {String}   object.mediantime           1545402693
+   * @apiSuccess {Number}   object.verificationprogress 0.999998831622689
+   * @apiSuccess {Boolean}  object.chainwork            "000000000000000000000000000000000000000000d8c09a8ab7262080266b3e"
+   * @apiSuccess {Number}   object.pruned               false
+   * @apiSuccess {Array}    object.softforks            Array of objects
+   * @apiSuccess {String}   object.softforks.id         "bip34"
+   * @apiSuccess {String}   object.softforks.version    2
+   * @apiSuccess {Object}   object.softforks.reject
+   * @apiSuccess {String}   object.softforks.reject.status true
+   */
+  async getBlockchainInfo (req, res, next) {
+    try {
+      // Axios options
+      const options = _this.routeUtils.getAxiosOptions()
+      options.data.id = 'getblockchaininfo'
+      options.data.method = 'getblockchaininfo'
+      options.data.params = []
+
+      const response = await _this.axios.request(options)
+
+      return res.json(response.data.result)
+    } catch (err) {
+      // Write out error to error log.
+      wlogger.error('Error in blockchain.ts/getBlockchainInfo().', err)
+
+      return _this.errorHandler(err, res)
+    }
+  }
+
+  /**
+   * @api {get} /blockchain/getBlockCount Get Block Count
+   * @apiName GetBlockCount
+   * @apiGroup Blockchain
+   * @apiDescription Returns the number of blocks in the longest blockchain.
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v4/blockchain/getBlockCount" -H "accept: application/json"
+   *
+   * @apiSuccess {Number} bestBlockCount  587665
+   */
+  async getBlockCount (req, res, next) {
+    try {
+      // Axios options
+      const options = _this.routeUtils.getAxiosOptions()
+      options.data.id = 'getblockcount'
+      options.data.method = 'getblockcount'
+      options.data.params = []
+
+      const response = await _this.axios.request(options)
+
+      return res.json(response.data.result)
+    } catch (err) {
+      // Write out error to error log.
+      // logger.error(`Error in rawtransactions/decodeRawTransaction: `, err)
+      wlogger.error('Error in blockchain.ts/getBlockCount().', err)
+
+      return _this.errorHandler(err, res)
+    }
+  }
+
+  /**
+   * @api {get} /blockchain/getBlockHeader/:hash Get single block header
+   * @apiName GetSingleBlockHeader
+   * @apiGroup Blockchain
+   * @apiDescription If verbose is false (default), returns a string that is
+   * serialized, hex-encoded data for blockheader 'hash'. If verbose is true,
+   * returns an Object with information about blockheader hash.
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v4/blockchain/getBlockHeader/000000000000000005e14d3f9fdfb70745308706615cfa9edca4f4558332b201?verbose=true" -H "accept: application/json"
+   *
+   * @apiParam {String} hash block hash
+   * @apiParam {Boolean} verbose Return verbose data
+   *
+   * @apiSuccess {Object}   object                      Object containing data
+   * @apiSuccess {String}   object.hash                "000000000000000005e14d3f9fdfb70745308706615cfa9edca4f4558332b201"
+   * @apiSuccess {Number}   object.confirmations       61839
+   * @apiSuccess {Number}   object.height              500000
+   * @apiSuccess {Number}   object.version             536870912
+   * @apiSuccess {String}   object.versionHex          "20000000"
+   * @apiSuccess {String}   object.merkleroot          "4af279645e1b337e655ae3286fc2ca09f58eb01efa6ab27adedd1e9e6ec19091"
+   * @apiSuccess {Number}   object.time                1509343584
+   * @apiSuccess {Number}   object.mediantime          1509336533
+   * @apiSuccess {Number}   object.nonce               3604508752
+   * @apiSuccess {String}   object.bits                "1809b91a"
+   * @apiSuccess {Number}   object.difficulty          113081236211.4533
+   * @apiSuccess {String}   object.chainwork           "0000000000000000000000000000000000000000007ae48aca46e3b449ad9714"
+   * @apiSuccess {String}   object.previousblockhash   "0000000000000000043831d6ebb013716f0580287ee5e5687e27d0ed72e6e523"
+   * @apiSuccess {String}   object.nextblockhash       "00000000000000000568f0a96bf4348847bc84e455cbfec389f27311037a20f3"
+   */
+  async getBlockHeaderSingle (req, res, next) {
+    try {
+      let verbose = false
+      if (req.query.verbose && req.query.verbose.toString() === 'true') {
+        verbose = true
+      }
+
+      const hash = req.params.hash
+      if (!hash || hash === '') {
+        res.status(400)
+        return res.json({ error: 'hash can not be empty' })
+      }
+
+      // Axios options
+      const options = _this.routeUtils.getAxiosOptions()
+      options.data.id = 'getblockheader'
+      options.data.method = 'getblockheader'
+      options.data.params = [hash, verbose]
+
+      const response = await _this.axios.request(options)
+
+      return res.json(response.data.result)
+    } catch (err) {
+      // Write out error to error log.
+      // logger.error(`Error in rawtransactions/decodeRawTransaction: `, err)
+      wlogger.error('Error in blockchain.ts/getBlockHeaderSingle().', err)
+
+      return _this.errorHandler(err, res)
+    }
+  }
+
+  /**
+   * @api {post} /blockchain/getBlockHeader Get multiple block headers
+   * @apiName GetBulkBlockHeader
+   * @apiGroup Blockchain
+   * @apiDescription If verbose is false (default), returns a string that is
+   * serialized, hex-encoded data for blockheader 'hash'. If verbose is true,
+   * returns an Object with information about blockheader hash.
+   *
+   * @apiExample Example usage:
+   * curl -X POST "https://api.fullstack.cash/v4/blockchain/getBlockHeader" -H "accept: application/json" -H "Content-Type: application/json" -d "{\"hashes\":[\"000000000000000005e14d3f9fdfb70745308706615cfa9edca4f4558332b201\",\"00000000000000000568f0a96bf4348847bc84e455cbfec389f27311037a20f3\"],\"verbose\":true}"
+   *
+   * @apiParam {String} hash block hash
+   * @apiParam {Boolean} verbose Return verbose data
+   *
+   * @apiSuccess {Array}    array                      array containing objects
+   * @apiSuccess {String}   object.hash                "000000000000000005e14d3f9fdfb70745308706615cfa9edca4f4558332b201"
+   * @apiSuccess {Number}   object.confirmations       61839
+   * @apiSuccess {Number}   object.height              500000
+   * @apiSuccess {Number}   object.version             536870912
+   * @apiSuccess {String}   object.versionHex          "20000000"
+   * @apiSuccess {String}   object.merkleroot          "4af279645e1b337e655ae3286fc2ca09f58eb01efa6ab27adedd1e9e6ec19091"
+   * @apiSuccess {Number}   object.time                1509343584
+   * @apiSuccess {Number}   object.mediantime          1509336533
+   * @apiSuccess {Number}   object.nonce               3604508752
+   * @apiSuccess {String}   object.bits                "1809b91a"
+   * @apiSuccess {Number}   object.difficulty          113081236211.4533
+   * @apiSuccess {String}   object.chainwork           "0000000000000000000000000000000000000000007ae48aca46e3b449ad9714"
+   * @apiSuccess {String}   object.previousblockhash   "0000000000000000043831d6ebb013716f0580287ee5e5687e27d0ed72e6e523"
+   * @apiSuccess {String}   object.nextblockhash       "00000000000000000568f0a96bf4348847bc84e455cbfec389f27311037a20f3"
+   */
+  async getBlockHeaderBulk (req, res, next) {
+    try {
+      const hashes = req.body.hashes
+      const verbose = req.body.verbose ? req.body.verbose : false
+
+      if (!Array.isArray(hashes)) {
+        res.status(400)
+        return res.json({
+          error: 'hashes needs to be an array. Use GET for single hash.'
+        })
+      }
+
+      // Enforce array size rate limits
+      if (!routeUtils.validateArraySize(req, hashes)) {
+        res.status(429) // https://github.com/Bitcoin-com/api.fullstack.cash/issues/330
+        return res.json({
+          error: 'Array too large.'
+        })
+      }
+
+      wlogger.debug(
+        'Executing blockchain/getBlockHeaderBulk with these hashes: ',
+        hashes
+      )
+
+      // Validate each hash in the array.
+      for (let i = 0; i < hashes.length; i++) {
+        const hash = hashes[i]
+
+        if (hash.length !== 64) {
+          res.status(400)
+          return res.json({ error: `This is not a hash: ${hash}` })
+        }
+      }
+
+      // Axios options
+      const options = _this.routeUtils.getAxiosOptions()
+
+      // Loop through each hash and creates an array of requests to call in parallel
+      const promises = hashes.map(async (hash) => {
+        options.data.id = 'getblockheader'
+        options.data.method = 'getblockheader'
+        options.data.params = [hash, verbose]
+
+        return _this.axios.request(options)
+      })
+
+      const axiosResult = await _this.axios.all(promises)
+
+      // Extract the data component from the axios response.
+      const result = axiosResult.map((x) => x.data.result)
+
+      res.status(200)
+      return res.json(result)
+    } catch (err) {
+      // Write out error to error log.
+      // logger.error(`Error in rawtransactions/decodeRawTransaction: `, err)
+      wlogger.error('Error in blockchain.ts/getBlockHeaderBulk().', err)
+
+      return _this.errorHandler(err, res)
+    }
+  }
+
+  /**
+   * @api {get} /blockchain/getChainTips Get Chain Tips
+   * @apiName getChainTips
+   * @apiGroup Blockchain
+   * @apiDescription Return information about all known tips in the block tree,
+   * including the main chain as well as orphaned branches.
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v4/blockchain/getChainTips" -H "accept: application/json"
+   *
+   */
+  async getChainTips (req, res, next) {
+    try {
+      // Axios options
+      const options = _this.routeUtils.getAxiosOptions()
+
+      options.data.id = 'getchaintips'
+      options.data.method = 'getchaintips'
+      options.data.params = []
+
+      const response = await _this.axios.request(options)
+      return res.json(response.data.result)
+    } catch (err) {
+      // Write out error to error log.
+      // logger.error(`Error in rawtransactions/decodeRawTransaction: `, err)
+      wlogger.error('Error in blockchain.ts/getChainTips().', err)
+
+      return _this.errorHandler(err, res)
+    }
+  }
+
+  /**
+   * @api {get} /blockchain/getDifficulty Get difficulty
+   * @apiName getDifficulty
+   * @apiGroup Blockchain
+   * @apiDescription Get the current difficulty value, used to regulate mining
+   * power on the network.
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v4/blockchain/getDifficulty" -H "accept: application/json"
+   *
+   */
+  async getDifficulty (req, res, next) {
+    try {
+      // Axios options
+      const options = _this.routeUtils.getAxiosOptions()
+
+      options.data.id = 'getdifficulty'
+      options.data.method = 'getdifficulty'
+      options.data.params = []
+
+      const response = await _this.axios.request(options)
+
+      return res.json(response.data.result)
+    } catch (err) {
+      // Write out error to error log.
+      // logger.error(`Error in rawtransactions/decodeRawTransaction: `, err)
+      wlogger.error('Error in blockchain.ts/getDifficulty().', err)
+
+      return _this.errorHandler(err, res)
+    }
+  }
+
+  /**
+   * @api {get} /blockchain/getMempoolEntry/:txid Get single mempool entry
+   * @apiName getMempoolEntry
+   * @apiGroup Blockchain
+   * @apiDescription Returns mempool data for given transaction. TXID must be in
+   * mempool (unconfirmed)
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v4/blockchain/getMempoolEntry/fe28050b93faea61fa88c4c630f0e1f0a1c24d0082dd0e10d369e13212128f33" -H "accept: application/json"
+   *
+   */
+  async getMempoolEntrySingle (req, res, next) {
+    try {
+      // Validate input parameter
+      const txid = req.params.txid
+      if (!txid || txid === '') {
+        res.status(400)
+        return res.json({ error: 'txid can not be empty' })
+      }
+
+      // Axios options
+      const options = _this.routeUtils.getAxiosOptions()
+
+      options.data.id = 'getmempoolentry'
+      options.data.method = 'getmempoolentry'
+      options.data.params = [txid]
+
+      const response = await _this.axios.request(options)
+
+      return res.json(response.data.result)
+    } catch (err) {
+      // Write out error to error log.
+      // logger.error(`Error in rawtransactions/decodeRawTransaction: `, err)
+      wlogger.error('Error in blockchain.ts/getMempoolEntrySingle().', err)
+
+      return _this.errorHandler(err, res)
+    }
+  }
+
+  /**
+   * @api {post} /blockchain/getMempoolEntry Get bulk mempool entry
+   * @apiName getMempoolEntryBulk
+   * @apiGroup Blockchain
+   * @apiDescription Returns mempool data for multiple transactions
+   *
+   * @apiExample Example usage:
+   * curl -X POST https://api.fullstack.cash/v4/blockchain/getMempoolEntry -H "Content-Type: application/json" -d "{\"txids\":[\"a5f972572ee1753e2fd2457dd61ce5f40fa2f8a30173d417e49feef7542c96a1\",\"5165dc531aad05d1149bb0f0d9b7bda99c73e2f05e314bcfb5b4bb9ca5e1af5e\"]}"
+   */
+  async getMempoolEntryBulk (req, res, next) {
+    try {
+      const txids = req.body.txids
+
+      if (!Array.isArray(txids)) {
+        res.status(400)
+        return res.json({
+          error: 'txids needs to be an array. Use GET for single txid.'
+        })
+      }
+
+      // Enforce array size rate limits
+      if (!routeUtils.validateArraySize(req, txids)) {
+        res.status(429) // https://github.com/Bitcoin-com/api.fullstack.cash/issues/330
+        return res.json({
+          error: 'Array too large.'
+        })
+      }
+
+      wlogger.debug(
+        'Executing blockchain/getMempoolEntry with these txids: ',
+        txids
+      )
+
+      // Validate each element in the array
+      for (let i = 0; i < txids.length; i++) {
+        const txid = txids[i]
+
+        if (txid.length !== 64) {
+          res.status(400)
+          return res.json({ error: 'This is not a txid' })
+        }
+      }
+
+      // Axios options
+      const options = _this.routeUtils.getAxiosOptions()
+
+      // Loop through each txid and creates an array of requests to call in parallel
+      const promises = txids.map(async (txid) => {
+        options.data.id = 'getmempoolentry'
+        options.data.method = 'getmempoolentry'
+        options.data.params = [txid]
+
+        return _this.axios.request(options)
+      })
+
+      const axiosResult = await _this.axios.all(promises)
+
+      // Extract the data component from the axios response.
+      const result = axiosResult.map((x) => x.data.result)
+
+      res.status(200)
+      return res.json(result)
+    } catch (err) {
+      // Write out error to error log.
+      // logger.error(`Error in rawtransactions/decodeRawTransaction: `, err)
+      wlogger.error('Error in blockchain.ts/getMempoolEntryBulk().', err)
+
+      return _this.errorHandler(err, res)
+    }
+  }
+
+  /**
+   * @api {get} /blockchain/getMempoolAncestors/:txid Get Mempool Ancestors
+   * @apiName getMempoolAncestors
+   * @apiGroup Blockchain
+   * @apiDescription Returns mempool ancestors data for given TXID. It must be in
+   * mempool (unconfirmed). This call is handy to tell if a UTXO is bumping up
+   * against the 25 ancestor chain-limit.
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v4/blockchain/getMempoolAncestors/fe28050b93faea61fa88c4c630f0e1f0a1c24d0082dd0e10d369e13212128f33" -H "accept: application/json"
+   *
+   */
+  async getMempoolAncestorsSingle (req, res, next) {
+    try {
+      // Validate input parameter
+      const txid = req.params.txid
+      if (!txid || txid === '') {
+        res.status(400)
+        return res.json({ error: 'txid can not be empty' })
+      }
+
+      let verbose = req.params.verbose
+      if (verbose === undefined) verbose = false
+
+      // Axios options
+      const options = _this.routeUtils.getAxiosOptions()
+
+      options.data.id = 'getmempoolancestors'
+      options.data.method = 'getmempoolancestors'
+      options.data.params = [txid, verbose]
+
+      const response = await _this.axios.request(options)
+      // console.log(`response: ${util.inspect(response)}`)
+
+      return res.json(response.data.result)
+    } catch (err) {
+      // Write out error to error log.
+      // logger.error(`Error in rawtransactions/decodeRawTransaction: `, err)
+      wlogger.error('Error in blockchain.ts/getMempoolAncestorsSingle().', err)
+
+      return _this.errorHandler(err, res)
+    }
+  }
+
+  /**
+   * @api {get} /blockchain/getMempoolInfo Get mempool info
+   * @apiName getMempoolInfo
+   * @apiGroup Blockchain
+   * @apiDescription Returns details on the active state of the TX memory pool.
+   *
+   * @apiExample Example usage:
+   * curl -X GET https://api.fullstack.cash/v4/getMempoolInfo -H "accept: application/json"
+   *
+   */
+  async getMempoolInfo (req, res, next) {
+    try {
+      // Axios options
+      const options = _this.routeUtils.getAxiosOptions()
+
+      options.data.id = 'getmempoolinfo'
+      options.data.method = 'getmempoolinfo'
+      options.data.params = []
+
+      const response = await _this.axios.request(options)
+      return res.json(response.data.result)
+    } catch (err) {
+      // Write out error to error log.
+      // logger.error(`Error in rawtransactions/decodeRawTransaction: `, err)
+      wlogger.error('Error in blockchain.ts/getMempoolInfo().', err)
+
+      return _this.errorHandler(err, res)
+    }
+  }
+
+  /**
+   * @api {get} /blockchain/getRawMempool Get mempool info
+   * @apiName getMempoolInfo
+   * @apiGroup Blockchain
+   * @apiDescription Returns details on the active state of the TX memory pool.
+   *
+   * @apiExample Example usage:
+   * curl -X GET https://api.fullstack.cash/v4/getMempoolInfo -H "accept: application/json"
+   *
+   */
+
+  /**
+   * @api {get} /blockchain/getRawMempool/?verbose= Get raw mempool
+   * @apiName getRawMempool
+   * @apiGroup Blockchain
+   * @apiDescription Returns all transaction ids in memory pool as a json array
+   * of string transaction ids.
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v4/getRawMempool/?verbose=true" -H "accept: application/json"
+   *
+   * @apiParam {Boolean} verbose Return verbose data
+   *
+   */
+  async getRawMempool (req, res, next) {
+    try {
+      // Axios options
+      const options = _this.routeUtils.getAxiosOptions()
+
+      let verbose = false
+      if (req.query.verbose && req.query.verbose === 'true') verbose = true
+
+      options.data.id = 'getrawmempool'
+      options.data.method = 'getrawmempool'
+      options.data.params = [verbose]
+
+      const response = await _this.axios.request(options)
+
+      return res.json(response.data.result)
+    } catch (err) {
+      // Write out error to error log.
+      // logger.error(`Error in rawtransactions/decodeRawTransaction: `, err)
+      wlogger.error('Error in blockchain.ts/getRawMempool().', err)
+
+      return _this.errorHandler(err, res)
+    }
+  }
+
+  /**
+   * @api {get} /blockchain/getTxOut/:txid/:n?mempool= Get Tx Out
+   * @apiName getTxOut
+   * @apiGroup Blockchain
+   * @apiDescription Returns details about an unspent transaction output.
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v4/blockchain/getTxOut/fe28050b93faea61fa88c4c630f0e1f0a1c24d0082dd0e10d369e13212128f33/0?mempool=false" -H "accept: application/json"
+   *
+   * @apiParam {String} txid Transaction id (required)
+   * @apiParam {Number} n Output number (required)
+   * @apiParam {Boolean} mempool Check mempool or not (optional)
+   *
+   */
+  // Returns details about an unspent transaction output.
+  async getTxOut (req, res, next) {
+    try {
+      // Validate input parameter
+      const txid = req.params.txid
+      if (!txid || txid === '') {
+        res.status(400)
+        return res.json({ error: 'txid can not be empty' })
+      }
+
+      let n = req.params.n
+      if (n === undefined || n === '') {
+        res.status(400)
+        return res.json({ error: 'n can not be empty' })
+      }
+      n = parseInt(n)
+
+      let includeMempool = false
+      if (req.query.includeMempool && req.query.includeMempool === 'true') {
+        includeMempool = true
+      }
+
+      // Axios options
+      const options = _this.routeUtils.getAxiosOptions()
+
+      options.data.id = 'gettxout'
+      options.data.method = 'gettxout'
+      options.data.params = [txid, n, includeMempool]
+
+      // console.log(`requestConfig: ${JSON.stringify(requestConfig, null, 2)}`)
+
+      const response = await _this.axios.request(options)
+
+      return res.json(response.data.result)
+    } catch (err) {
+      // Write out error to error log.
+      // logger.error(`Error in rawtransactions/decodeRawTransaction: `, err)
+      wlogger.error('Error in blockchain.ts/getTxOut().', err)
+
+      return _this.errorHandler(err, res)
+    }
+  }
+
+  /**
+   * @api {post} /blockchain/getTxOut Validate a UTXO
+   * @apiName getTxOut
+   * @apiGroup Blockchain
+   * @apiDescription Returns details about an unspent transaction output (UTXO).
+   *
+   * @apiExample Example usage:
+   * curl "https://api.fullstack.cash/v4/blockchain/getTxOut/" -X POST -H "Content-Type: application/json" --data-binary '{"txid":"d5228d2cdc77fbe5a9aa79f19b0933b6802f9f0067f42847fc4fe343664723e5","vout":0,"mempool":true}'
+   *
+   * @apiParam {String} txid Transaction id (required)
+   * @apiParam {Number} vout of transaction (required)
+   * @apiParam {Boolean} mempool Check mempool or not (optional)
+   *
+   */
+  // Returns details about an unspent transaction output.
+  async getTxOutPost (req, res, next) {
+    try {
+      const txid = req.body.txid
+      let n = req.body.vout
+      const mempool = req.body.mempool ? req.body.mempool : true
+
+      // Validate input parameter
+      if (!txid || txid === '') {
+        res.status(400)
+        return res.json({ error: 'txid can not be empty' })
+      }
+
+      if (n === undefined || n === '') {
+        res.status(400)
+        return res.json({ error: 'vout can not be empty' })
+      }
+      n = parseInt(n)
+
+      // Axios options
+      const options = _this.routeUtils.getAxiosOptions()
+
+      options.data.id = 'gettxout'
+      options.data.method = 'gettxout'
+      options.data.params = [txid, n, mempool]
+
+      // console.log(`requestConfig: ${JSON.stringify(requestConfig, null, 2)}`)
+
+      const response = await _this.axios.request(options)
+
+      return res.json(response.data.result)
+    } catch (err) {
+      // Write out error to error log.
+      // logger.error(`Error in rawtransactions/decodeRawTransaction: `, err)
+      wlogger.error('Error in blockchain.ts/getTxOutPost().', err)
+
+      return _this.errorHandler(err, res)
+    }
+  }
+
+  /**
+   * @api {get} /blockchain/getTxOutProofSingle/:txid Get Tx Out Proof
+   * @apiName getTxOutProofSingle
+   * @apiGroup Blockchain
+   * @apiDescription Returns a hex-encoded proof that 'txid' was included in a block.
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v4/blockchain/getTxOutProofSingle/fe28050b93faea61fa88c4c630f0e1f0a1c24d0082dd0e10d369e13212128f33" -H "accept: application/json"
+   *
+   * @apiParam {String} txid Transaction id (required)
+   *
+   */
+  async getTxOutProofSingle (req, res, next) {
+    try {
+      // Validate input parameter
+      const txid = req.params.txid
+      if (!txid || txid === '') {
+        res.status(400)
+        return res.json({ error: 'txid can not be empty' })
+      }
+
+      // Axios options
+      const options = _this.routeUtils.getAxiosOptions()
+
+      options.data.id = 'gettxoutproof'
+      options.data.method = 'gettxoutproof'
+      options.data.params = [[txid]]
+
+      const response = await _this.axios.request(options)
+
+      return res.json(response.data.result)
+    } catch (err) {
+      // Write out error to error log.
+      // logger.error(`Error in rawtransactions/decodeRawTransaction: `, err)
+      wlogger.error('Error in blockchain.ts/getTxOutProofSingle().', err)
+
+      return _this.errorHandler(err, res)
+    }
+  }
+
+  // Returns a hex-encoded proof that 'txid' was included in a block.
+  async getTxOutProofBulk (req, res, next) {
+    try {
+      const txids = req.body.txids
+
+      // Reject if txids is not an array.
+      if (!Array.isArray(txids)) {
+        res.status(400)
+        return res.json({
+          error: 'txids needs to be an array. Use GET for single txid.'
+        })
+      }
+
+      // Enforce array size rate limits
+      if (!routeUtils.validateArraySize(req, txids)) {
+        res.status(429) // https://github.com/Bitcoin-com/api.fullstack.cash/issues/330
+        return res.json({
+          error: 'Array too large.'
+        })
+      }
+
+      // Axios options
+      const options = _this.routeUtils.getAxiosOptions()
+
+      // Validate each element in the array.
+      for (let i = 0; i < txids.length; i++) {
+        const txid = txids[i]
+
+        if (txid.length !== 64) {
+          res.status(400)
+          return res.json({
+            error: `Invalid txid. Double check your txid is valid: ${txid}`
+          })
+        }
+      }
+
+      wlogger.debug(
+        'Executing blockchain/getTxOutProof with these txids: ',
+        txids
+      )
+
+      // Loop through each txid and creates an array of requests to call in parallel
+      const promises = txids.map(async (txid) => {
+        options.data.id = 'gettxoutproof'
+        options.data.method = 'gettxoutproof'
+        options.data.params = [[txid]]
+
+        return _this.axios.request(options)
+      })
+
+      // Wait for all parallel promisses to resolve.
+      const axiosResult = await _this.axios.all(promises)
+
+      // Extract the data component from the axios response.
+      const result = axiosResult.map((x) => x.data.result)
+
+      res.status(200)
+      return res.json(result)
+    } catch (err) {
+      // Write out error to error log.
+      // logger.error(`Error in rawtransactions/decodeRawTransaction: `, err)
+      wlogger.error('Error in blockchain.ts/getTxOutProofBulk().', err)
+
+      return _this.errorHandler(err, res)
+    }
+  }
+
+  async verifyTxOutProofSingle (req, res, next) {
+    try {
+      // Validate input parameter
+      const proof = req.params.proof
+      if (!proof || proof === '') {
+        res.status(400)
+        return res.json({ error: 'proof can not be empty' })
+      }
+
+      // Axios options
+      const options = _this.routeUtils.getAxiosOptions()
+
+      options.data.id = 'verifytxoutproof'
+      options.data.method = 'verifytxoutproof'
+      options.data.params = [req.params.proof]
+
+      const response = await _this.axios.request(options)
+
+      return res.json(response.data.result)
+    } catch (err) {
+      // Write out error to error log.
+      // logger.error(`Error in rawtransactions/decodeRawTransaction: `, err)
+      wlogger.error('Error in blockchain.ts/verifyTxOutProofSingle().', err)
+
+      return _this.errorHandler(err, res)
+    }
+  }
+
+  async verifyTxOutProofBulk (req, res, next) {
+    try {
+      const proofs = req.body.proofs
+
+      // Reject if proofs is not an array.
+      if (!Array.isArray(proofs)) {
+        res.status(400)
+        return res.json({
+          error: 'proofs needs to be an array. Use GET for single proof.'
+        })
+      }
+
+      // Enforce array size rate limits
+      if (!routeUtils.validateArraySize(req, proofs)) {
+        res.status(429) // https://github.com/Bitcoin-com/api.fullstack.cash/issues/330
+        return res.json({
+          error: 'Array too large.'
+        })
+      }
+
+      // Axios options
+      const options = _this.routeUtils.getAxiosOptions()
+
+      // Validate each element in the array.
+      for (let i = 0; i < proofs.length; i++) {
+        const proof = proofs[i]
+
+        if (!proof || proof === '') {
+          res.status(400)
+          return res.json({ error: `proof can not be empty: ${proof}` })
+        }
+      }
+
+      wlogger.debug(
+        'Executing blockchain/verifyTxOutProof with these proofs: ',
+        proofs
+      )
+
+      // Loop through each proof and creates an array of requests to call in parallel
+      const promises = proofs.map(async (proof) => {
+        options.data.id = 'verifytxoutproof'
+        options.data.method = 'verifytxoutproof'
+        options.data.params = [proof]
+
+        return _this.axios.request(options)
+      })
+
+      // Wait for all parallel promisses to resolve.
+      const axiosResult = await _this.axios.all(promises)
+
+      // Extract the data component from the axios response.
+      const result = axiosResult.map((x) => x.data.result[0])
+
+      res.status(200)
+      return res.json(result)
+    } catch (err) {
+      // Write out error to error log.
+      // logger.error(`Error in rawtransactions/decodeRawTransaction: `, err)
+      wlogger.error('Error in blockchain.ts/verifyTxOutProofBulk().', err)
+
+      return _this.errorHandler(err, res)
+    }
+  }
+}
+
+module.exports = Blockchain

src/routes/v4/full-node/control.js

@@ -0,0 +1,116 @@
+'use strict'
+
+const express = require('express')
+const router = express.Router()
+
+const axios = require('axios')
+
+// const routeUtils = require('../route-utils')
+const wlogger = require('../../../util/winston-logging')
+
+const RouteUtils = require('../../../util/route-utils')
+const routeUtils = new RouteUtils()
+
+// Used for processing error messages before sending them to the user.
+const util = require('util')
+util.inspect.defaultOptions = { depth: 1 }
+
+let _this
+
+class Control {
+  constructor () {
+    _this = this
+
+    _this.axios = axios
+    _this.routeUtils = routeUtils
+
+    _this.router = router
+    _this.router.get('/', _this.root)
+    _this.router.get('/getNetworkInfo', _this.getNetworkInfo)
+  }
+
+  root (req, res, next) {
+    return res.json({ status: 'control' })
+  }
+
+  // DRY error handler.
+  errorHandler (err, res) {
+    // Attempt to decode the error message.
+    const { msg, status } = _this.routeUtils.decodeError(err)
+    if (msg) {
+      res.status(status)
+      return res.json({ error: msg })
+    }
+
+    res.status(500)
+    return res.json({ error: util.inspect(err) })
+  }
+
+  /**
+   * @api {get} /control/getnetworkinfo Get Network Info
+   * @apiName GetNetworkInfo
+   * @apiGroup Control
+   * @apiDescription RPC call which gets basic full node information.
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v4/control/getnetworkinfo" -H "accept: application/json"
+   *
+   */
+  async getNetworkInfo (req, res, next) {
+    // Axios options
+    const options = _this.routeUtils.getAxiosOptions()
+
+    options.data.id = 'getnetworkinfo'
+    options.data.method = 'getnetworkinfo'
+    options.data.params = []
+
+    try {
+      // const response = await BitboxHTTP(requestConfig)
+      const response = await _this.axios.request(options)
+
+      return res.json(response.data.result)
+    } catch (error) {
+      wlogger.error('Error in control.ts/getNetworkInfo().', error)
+
+      return _this.errorHandler(error, res)
+    }
+  }
+  // router.get('/getMemoryInfo', (req, res, next) => {
+  //   BitboxHTTP({
+  //     method: 'post',
+  //     auth: {
+  //       username: username,
+  //       password: password
+  //     },
+  //     data: {
+  //       jsonrpc: "1.0",
+  //       id:"getmemoryinfo",
+  //       method: "getmemoryinfo"
+  //     }
+  //   })
+  //   .then((response) => {
+  //     res.json(response.data.result);
+  //   })
+  //   .catch((error) => {
+  //     res.send(error.response.data.error.message);
+  //   });
+  // });
+  //
+  // router.get('/help', (req, res, next) => {
+  //   BITBOX.Control.help()
+  //   .then((result) => {
+  //     res.json(result);
+  //   }, (err) => { console.log(err);
+  //   });
+  // });
+  //
+  // router.post('/stop', (req, res, next) => {
+  //   BITBOX.Control.stop()
+  //   .then((result) => {
+  //     res.json(result);
+  //   }, (err) => { console.log(err);
+  //   });
+  // });
+}
+
+module.exports = Control

src/routes/v4/full-node/mining.js

@@ -0,0 +1,169 @@
+'use strict'
+
+const express = require('express')
+const router = express.Router()
+const axios = require('axios')
+
+const RouteUtils = require('../../../util/route-utils')
+const routeUtils = new RouteUtils()
+
+const wlogger = require('../../../util/winston-logging')
+
+// Used to convert error messages to strings, to safely pass to users.
+const util = require('util')
+util.inspect.defaultOptions = { depth: 1 }
+
+let _this
+
+class Mining {
+  constructor () {
+    _this = this
+
+    _this.axios = axios
+    _this.routeUtils = routeUtils
+
+    _this.router = router
+    _this.router.get('/', _this.root)
+    _this.router.get('/getMiningInfo', _this.getMiningInfo)
+    _this.router.get('/getNetworkHashPS', _this.getNetworkHashPS)
+  }
+
+  root (req, res, next) {
+    return res.json({ status: 'mining' })
+  }
+
+  // DRY error handler.
+  errorHandler (err, res) {
+    // Attempt to decode the error message.
+    const { msg, status } = _this.routeUtils.decodeError(err)
+    if (msg) {
+      res.status(status)
+      return res.json({ error: msg })
+    }
+
+    res.status(500)
+    return res.json({ error: util.inspect(err) })
+  }
+
+  // router.get('/getBlockTemplate/:templateRequest', (req, res, next) => {
+  //   BitboxHTTP({
+  //     method: 'post',
+  //     auth: {
+  //       username: username,
+  //       password: password
+  //     },
+  //     data: {
+  //       jsonrpc: "1.0",
+  //       id:"getblocktemplate",
+  //       method: "getblocktemplate",
+  //       params: [
+  //         req.params.templateRequest
+  //       ]
+  //     }
+  //   })
+  //   .then((response) => {
+  //     res.json(response.data.result);
+  //   })
+  //   .catch((error) => {
+  //     res.send(error.response.data.error.message);
+  //   });
+  // });
+
+  /**
+   * @api {get} /mining/getMiningInfo  Get Mining Info.
+   * @apiName Mining info.
+   * @apiGroup Mining
+   * @apiDescription Returns a json object containing mining-related information.
+   *
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v4/mining/getMiningInfo" -H "accept: application/json"
+   *
+   *
+   */
+  async getMiningInfo (req, res, next) {
+    try {
+      const options = _this.routeUtils.getAxiosOptions()
+
+      options.data.id = 'getmininginfo'
+      options.data.method = 'getmininginfo'
+      options.data.params = []
+
+      const response = await _this.axios.request(options)
+
+      return res.json(response.data.result)
+    } catch (err) {
+      wlogger.error('Error in mining.ts/getMiningInfo().', err)
+
+      return _this.errorHandler(err, res)
+    }
+  }
+
+  /**
+   * @api {get} /mining/getNetworkHashps?nblocks=&height=  Get Estimated network hashes per second.
+   * @apiName Estimated network hashes per second.
+   * @apiGroup Mining
+   * @apiDescription Returns the estimated network hashes per second based on the last n blocks. Pass in [blocks] to override # of blocks, -1 specifies since last difficulty change. Pass in [height] to estimate the network speed at the time when a certain block was found.
+   *
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v4/mining/getNetworkHashps?nblocks=120&height=-1" -H "accept: application/json"
+   *
+   *
+   */
+
+  async getNetworkHashPS (req, res, next) {
+    try {
+      let nblocks = 120 // Default
+      let height = -1 // Default
+      if (req.query.nblocks) nblocks = parseInt(req.query.nblocks)
+      if (req.query.height) height = parseInt(req.query.height)
+
+      const options = _this.routeUtils.getAxiosOptions()
+
+      options.data.id = 'getnetworkhashps'
+      options.data.method = 'getnetworkhashps'
+      options.data.params = [nblocks, height]
+
+      const response = await _this.axios.request(options)
+
+      return res.json(response.data.result)
+    } catch (err) {
+      wlogger.error('Error in mining.ts/getNetworkHashPS().', err)
+
+      return _this.errorHandler(err, res)
+    }
+  }
+
+  // router.post('/submitBlock/:hex', (req, res, next) => {
+  //   let parameters = '';
+  //   if(req.query.parameters && req.query.parameters !== '') {
+  //     parameters = true;
+  //   }
+  //
+  //   BitboxHTTP({
+  //     method: 'post',
+  //     auth: {
+  //       username: username,
+  //       password: password
+  //     },
+  //     data: {
+  //       jsonrpc: "1.0",
+  //       id:"submitblock",
+  //       method: "submitblock",
+  //       params: [
+  //         req.params.hex,
+  //         parameters
+  //       ]
+  //     }
+  //   })
+  //   .then((response) => {
+  //     res.json(response.data.result);
+  //   })
+  //   .catch((error) => {
+  //     res.send(error.response.data.error.message);
+  //   });
+  // });
+}
+
+module.exports = Mining

src/routes/v4/full-node/network.js

@@ -0,0 +1,168 @@
+'use strict'
+
+const express = require('express')
+const router = express.Router()
+
+router.get('/', async (req, res, next) => {
+  res.json({ status: 'network' })
+})
+
+// router.post('/addNode/:node/:command', (req, res, next) => {
+//   BITBOX.Network.addNode(req.params.node, req.params.command)
+//   .then((result) => {
+//     res.json(result);
+//   }, (err) => { console.log(err);
+//     });
+// });
+//
+// router.post('/clearBanned', (req, res, next) => {
+//   BITBOX.Network.clearBanned()
+//   .then((result) => {
+//     res.json(result);
+//   }, (err) => { console.log(err);
+//   });
+// });
+//
+// router.post('/disconnectNode/:address/:nodeid', (req, res, next) => {
+//   BITBOX.Network.disconnectNode(req.params.address, req.params.nodeid)
+//   .then((result) => {
+//     res.json(result);
+//   }, (err) => { console.log(err);
+//   });
+// });
+//
+// router.get('/getAddedNodeInfo/:node', (req, res, next) => {
+//   BITBOX.Network.getAddedNodeInfo(req.params.node)
+//   .then((result) => {
+//     res.json(result);
+//   }, (err) => { console.log(err);
+//   });
+// });
+//
+// router.get('/getConnectionCount', (req, res, next) => {
+//   BitboxHTTP({
+//     method: 'post',
+//     auth: {
+//       username: username,
+//       password: password
+//     },
+//     data: {
+//       jsonrpc: "1.0",
+//       id:"getconnectioncount",
+//       method: "getconnectioncount"
+//     }
+//   })
+//   .then((response) => {
+//     res.json(response.data.result);
+//   })
+//   .catch((error) => {
+//     res.send(error.response.data.error.message);
+//   });
+// });
+//
+// router.get('/getNetTotals', (req, res, next) => {
+//   BitboxHTTP({
+//     method: 'post',
+//     auth: {
+//       username: username,
+//       password: password
+//     },
+//     data: {
+//       jsonrpc: "1.0",
+//       id:"getnettotals",
+//       method: "getnettotals"
+//     }
+//   })
+//   .then((response) => {
+//     res.json(response.data.result);
+//   })
+//   .catch((error) => {
+//     res.send(error.response.data.error.message);
+//   });
+// });
+//
+// router.get('/getNetworkInfo', (req, res, next) => {
+//   BitboxHTTP({
+//     method: 'post',
+//     auth: {
+//       username: username,
+//       password: password
+//     },
+//     data: {
+//       jsonrpc: "1.0",
+//       id:"getnetworkinfo",
+//       method: "getnetworkinfo"
+//     }
+//   })
+//   .then((response) => {
+//     res.json(response.data.result);
+//   })
+//   .catch((error) => {
+//     res.send(error.response.data.error.message);
+//   });
+// });
+//
+// router.get('/getPeerInfo', (req, res, next) => {
+//   BitboxHTTP({
+//     method: 'post',
+//     auth: {
+//       username: username,
+//       password: password
+//     },
+//     data: {
+//       jsonrpc: "1.0",
+//       id:"getpeerinfo",
+//       method: "getpeerinfo"
+//     }
+//   })
+//   .then((response) => {
+//     res.json(response.data.result);
+//   })
+//   .catch((error) => {
+//     res.send(error.response.data.error.message);
+//   });
+// });
+//
+// router.get('/ping', (req, res, next) => {
+//   BitboxHTTP({
+//     method: 'post',
+//     auth: {
+//       username: username,
+//       password: password
+//     },
+//     data: {
+//       jsonrpc: "1.0",
+//       id:"ping",
+//       method: "ping"
+//     }
+//   })
+//   .then((response) => {
+//     res.json(JSON.stringify(response.data.result));
+//   })
+//   .catch((error) => {
+//     res.send(error.response.data.error.message);
+//   });
+// });
+//
+// router.post('/setBan/:subnet/:command', (req, res, next) => {
+//   // TODO finish this
+//   BITBOX.Network.getConnectionCount(req.params.subnet, req.params.command)
+//   .then((result) => {
+//     res.json(result);
+//   }, (err) => { console.log(err);
+//   });
+// });
+//
+// router.post('/setNetworkActive/:state', (req, res, next) => {
+//   let state = true;
+//   if(req.params.state  && req.params.state === 'false') {
+//     state = false;
+//   }
+//   BITBOX.Network.getConnectionCount(state)
+//   .then((result) => {
+//     res.json(result);
+//   }, (err) => { console.log(err);
+//   });
+// });
+
+module.exports = router

src/routes/v4/full-node/rawtransactions.js

@@ -0,0 +1,570 @@
+'use strict'
+
+const express = require('express')
+const router = express.Router()
+const axios = require('axios')
+
+const RouteUtils = require('../../../util/route-utils')
+const routeUtils = new RouteUtils()
+
+const wlogger = require('../../../util/winston-logging')
+
+// Used to convert error messages to strings, to safely pass to users.
+const util = require('util')
+util.inspect.defaultOptions = { depth: 1 }
+
+let _this
+class RawTransactions {
+  constructor () {
+    _this = this
+
+    // Encapsulate external dependencies.
+    this.axios = axios
+    this.routeUtils = routeUtils
+
+    // Define Express routes.
+    this.router = router
+    this.router.get('/', this.root)
+    this.router.get(
+      '/decodeRawTransaction/:hex',
+      this.decodeRawTransactionSingle
+    )
+    this.router.post('/decodeRawTransaction', this.decodeRawTransactionBulk)
+    this.router.get('/decodeScript/:hex', this.decodeScriptSingle)
+    this.router.post('/decodeScript', this.decodeScriptBulk)
+    this.router.post('/getRawTransaction', this.getRawTransactionBulk)
+    this.router.get('/getRawTransaction/:txid', this.getRawTransactionSingle)
+    this.router.post('/sendRawTransaction', this.sendRawTransactionBulk)
+    this.router.get('/sendRawTransaction/:hex', this.sendRawTransactionSingle)
+  }
+
+  root (req, res, next) {
+    return res.json({ status: 'rawtransactions' })
+  }
+
+  // DRY error handler.
+  errorHandler (err, res) {
+    // Attempt to decode the error message.
+    const { msg, status } = _this.routeUtils.decodeError(err)
+    if (msg) {
+      res.status(status)
+      return res.json({ error: msg })
+    }
+
+    res.status(500)
+    return res.json({ error: util.inspect(err) })
+  }
+
+  // Decode transaction hex into a JSON object.
+  // GET
+  /**
+   * @api {get} /rawtransactions/decodeRawTransaction/{hex} Decode Single Raw Transaction.
+   * @apiName Decode Single Raw Transaction
+   * @apiGroup Raw Transaction
+   * @apiDescription Return a JSON object representing the serialized, hex-encoded transaction.
+   *
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v4/rawtransactions/decodeRawTransaction/02000000010e991f7ccec410f27d333f737f149b5d3be6728687da81072e638aed0063a176010000006b483045022100cd20443b0af090053450bc4ab00d563d4ac5955bb36e0135b00b8a96a19f233302205047f2c70a08c6ef4b76f2d198b33a31d17edfaa7e1e9e865894da0d396009354121024d4e7f522f67105b7bf5f9dbe557e7b2244613fdfcd6fe09304f93877328f6beffffffff02a0860100000000001976a9140ee020c07f39526ac5505c54fa1ab98490979b8388acb5f0f70b000000001976a9143a9b2b0c12fe722fcf653b6ef5dcc38732d6ff5188ac00000000" -H "accept: application/json"
+   */
+  async decodeRawTransactionSingle (req, res, next) {
+    try {
+      const hex = req.params.hex
+
+      // Throw an error if hex is empty.
+      if (!hex || hex === '') {
+        res.status(400)
+        return res.json({ error: 'hex can not be empty' })
+      }
+      const options = _this.routeUtils.getAxiosOptions()
+
+      options.data.id = 'decoderawtransaction'
+      options.data.method = 'decoderawtransaction'
+      options.data.params = [hex]
+
+      const response = await _this.axios.request(options)
+      return res.json(response.data.result)
+    } catch (err) {
+      // Write out error to error log.
+      // logger.error(`Error in rawtransactions/decodeRawTransaction: `, err)
+      wlogger.error(
+        'Error in rawtransactions.ts/decodeRawTransactionSingle().',
+        err
+      )
+      return _this.errorHandler(err, res)
+    }
+  }
+
+  /**
+   * @api {post} /rawtransactions/decodeRawTransaction Decode Bulk Raw Transactions.
+   * @apiName  Decode Bulk Raw Transactions
+   * @apiGroup Raw Transaction
+   * @apiDescription Return bulk hex encoded transaction.
+   *
+   *
+   * @apiExample Example usage:
+   * curl -X POST "https://api.fullstack.cash/v4/rawtransactions/decodeRawTransaction" -H "accept: application/json" -H "Content-Type: application/json" -d '{"hexes":["01000000013ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a000000006a4730440220540986d1c58d6e76f8f05501c520c38ce55393d0ed7ed3c3a82c69af04221232022058ea43ed6c05fec0eccce749a63332ed4525460105346f11108b9c26df93cd72012103083dfc5a0254613941ddc91af39ff90cd711cdcde03a87b144b883b524660c39ffffffff01807c814a000000001976a914d7e7c4e0b70eaa67ceff9d2823d1bbb9f6df9a5188ac00000000","01000000013ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a000000006a4730440220540986d1c58d6e76f8f05501c520c38ce55393d0ed7ed3c3a82c69af04221232022058ea43ed6c05fec0eccce749a63332ed4525460105346f11108b9c26df93cd72012103083dfc5a0254613941ddc91af39ff90cd711cdcde03a87b144b883b524660c39ffffffff01807c814a000000001976a914d7e7c4e0b70eaa67ceff9d2823d1bbb9f6df9a5188ac00000000"]}'
+   *
+   *
+   */
+  async decodeRawTransactionBulk (req, res, next) {
+    try {
+      const hexes = req.body.hexes
+
+      if (!Array.isArray(hexes)) {
+        res.status(400)
+        return res.json({ error: 'hexes must be an array' })
+      }
+
+      // Enforce array size rate limits
+      if (!_this.routeUtils.validateArraySize(req, hexes)) {
+        res.status(429) // https://github.com/Bitcoin-com/rest.bitcoin.com/issues/330
+        return res.json({
+          error: 'Array too large.'
+        })
+      }
+
+      // const results = []
+
+      // Validate each element in the address array.
+      for (let i = 0; i < hexes.length; i++) {
+        const thisHex = hexes[i]
+
+        // Reject if id is empty
+        if (!thisHex || thisHex === '') {
+          res.status(400)
+          return res.json({ error: 'Encountered empty hex' })
+        }
+      }
+
+      const options = _this.routeUtils.getAxiosOptions()
+
+      // Loop through each height and creates an array of requests to call in parallel
+      const promises = hexes.map(async hex => {
+        options.data.id = 'decoderawtransaction'
+        options.data.method = 'decoderawtransaction'
+        options.data.params = [hex]
+
+        return _this.axios.request(options)
+      })
+
+      // Wait for all parallel Insight requests to return.
+      const axiosResult = await _this.axios.all(promises)
+
+      // Retrieve the data part of the result.
+      const result = axiosResult.map(x => x.data.result)
+
+      res.status(200)
+      return res.json(result)
+    } catch (err) {
+      // Write out error to error log.
+      // logger.error(`Error in rawtransactions/getRawTransaction: `, err)
+      wlogger.error(
+        'Error in rawtransactions.ts/decodeRawTransactionBulk().',
+        err
+      )
+      return _this.errorHandler(err, res)
+    }
+  }
+
+  // Decode a raw transaction from hex to assembly.
+  // GET single
+  /**
+   * @api {get} /rawtransactions/decodeScript/{hex}  Decode Single Script.
+   * @apiName  Decode Single Script
+   * @apiGroup Raw Transaction
+   * @apiDescription Decode a hex-encoded script.
+   *
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v4/rawtransactions/decodeScript/4830450221009a51e00ec3524a7389592bc27bea4af5104a59510f5f0cfafa64bbd5c164ca2e02206c2a8bbb47eabdeed52f17d7df668d521600286406930426e3a9415fe10ed592012102e6e1423f7abde8b70bca3e78a7d030e5efabd3eb35c19302542b5fe7879c1a16" -H "accept: application/json"
+   *
+   *
+   */
+  async decodeScriptSingle (req, res, next) {
+    try {
+      const hex = req.params.hex
+
+      // Throw an error if hex is empty.
+      if (!hex || hex === '') {
+        res.status(400)
+        return res.json({ error: 'hex can not be empty' })
+      }
+
+      const options = _this.routeUtils.getAxiosOptions()
+
+      options.data.id = 'decodescript'
+      options.data.method = 'decodescript'
+      options.data.params = [hex]
+
+      const response = await _this.axios.request(options)
+      return res.json(response.data.result)
+    } catch (err) {
+      // Write out error to error log.
+      // logger.error(`Error in rawtransactions/decodeScript: `, err)
+      wlogger.error('Error in rawtransactions.ts/decodeScriptSingle().', err)
+
+      return _this.errorHandler(err, res)
+    }
+  }
+
+  // Decode a raw transaction from hex to assembly.
+  // POST bulk
+  /**
+   * @api {post} /rawtransactions/decodeScript  Bulk Decode Script.
+   * @apiName Bulk Decode Script
+   * @apiGroup Raw Transaction
+   * @apiDescription Decode multiple hex-encoded scripts.
+   *
+   *
+   * @apiExample Example usage:
+   *curl -X POST "https://api.fullstack.cash/v4/rawtransactions/decodeScript" -H "accept:" -H "Content-Type: application/json" -d '{"hexes":["01000000013ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a000000006a4730440220540986d1c58d6e76f8f05501c520c38ce55393d0ed7ed3c3a82c69af04221232022058ea43ed6c05fec0eccce749a63332ed4525460105346f11108b9c26df93cd72012103083dfc5a0254613941ddc91af39ff90cd711cdcde03a87b144b883b524660c39ffffffff01807c814a000000001976a914d7e7c4e0b70eaa67ceff9d2823d1bbb9f6df9a5188ac00000000","01000000013ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a000000006a4730440220540986d1c58d6e76f8f05501c520c38ce55393d0ed7ed3c3a82c69af04221232022058ea43ed6c05fec0eccce749a63332ed4525460105346f11108b9c26df93cd72012103083dfc5a0254613941ddc91af39ff90cd711cdcde03a87b144b883b524660c39ffffffff01807c814a000000001976a914d7e7c4e0b70eaa67ceff9d2823d1bbb9f6df9a5188ac00000000"]}'
+   *
+   *
+   */
+  async decodeScriptBulk (req, res, next) {
+    try {
+      const hexes = req.body.hexes
+
+      // Validation
+      if (!Array.isArray(hexes)) {
+        res.status(400)
+        return res.json({ error: 'hexes must be an array' })
+      }
+
+      // Enforce array size rate limits
+      if (!_this.routeUtils.validateArraySize(req, hexes)) {
+        res.status(429) // https://github.com/Bitcoin-com/rest.bitcoin.com/issues/330
+        return res.json({
+          error: 'Array too large.'
+        })
+      }
+
+      // Validate each hex in the array
+      for (let i = 0; i < hexes.length; i++) {
+        const hex = hexes[i]
+
+        // Throw an error if hex is empty.
+        if (!hex || hex === '') {
+          res.status(400)
+          return res.json({ error: 'Encountered empty hex' })
+        }
+      }
+
+      const options = _this.routeUtils.getAxiosOptions()
+
+      // Loop through each hex and create an array of promises
+      const promises = hexes.map(async hex => {
+        options.data.id = 'decodescript'
+        options.data.method = 'decodescript'
+        options.data.params = [hex]
+
+        const response = await _this.axios.request(options)
+        return response
+      })
+
+      // Wait for all parallel promises to return.
+      const resolved = await Promise.all(promises)
+
+      // Retrieve the data from each resolved promise.
+      const result = resolved.map(x => x.data.result)
+
+      res.status(200)
+      return res.json(result)
+    } catch (err) {
+      // Write out error to error log.
+      // logger.error(`Error in rawtransactions/decodeScript: `, err)
+      wlogger.error('Error in rawtransactions.ts/decodeScriptBulk().', err)
+      return _this.errorHandler(err, res)
+    }
+  }
+
+  // Retrieve raw transactions details from the full node.
+
+  async getRawTransactionsFromNode (txid, verbose) {
+    try {
+      const options = _this.routeUtils.getAxiosOptions()
+
+      options.data.id = 'getrawtransaction'
+      options.data.method = 'getrawtransaction'
+      options.data.params = [txid, verbose]
+
+      const response = await _this.axios.request(options)
+
+      return response.data.result
+    } catch (err) {
+      wlogger.error('Error in rawtransactions.ts/getRawTransactionsFromNode().')
+      throw err
+    }
+  }
+
+  // Get a JSON object breakdown of transaction details.
+  // POST
+  /**
+   * @api {post} /rawtransactions/getRawTransaction  Get Bulk Raw Transactions.
+   * @apiName Get Bulk Raw Transactions.
+   * @apiGroup Raw Transaction
+   * @apiDescription Return the raw transaction data for multiple transactions. If verbose is 'true', returns an Object with information about 'txid'. If verbose is 'false' or omitted, returns a string that is serialized, hex-encoded data for 'txid'.
+   *
+   *
+   * @apiExample Example usage:
+   * curl -X POST "https://api.fullstack.cash/v4/rawtransactions/getRawTransaction" -H "accept: application/json" -H "Content-Type: application/json" -d '{"txids":["a5f972572ee1753e2fd2457dd61ce5f40fa2f8a30173d417e49feef7542c96a1","5165dc531aad05d1149bb0f0d9b7bda99c73e2f05e314bcfb5b4bb9ca5e1af5e"],"verbose":true}'
+   *
+   */
+  async getRawTransactionBulk (req, res, next) {
+    try {
+      let verbose = 0
+      if (req.body.verbose) verbose = 1
+
+      const txids = req.body.txids
+      if (!Array.isArray(txids)) {
+        res.status(400)
+        return res.json({ error: 'txids must be an array' })
+      }
+
+      // Enforce array size rate limits
+      if (!_this.routeUtils.validateArraySize(req, txids)) {
+        res.status(429) // https://github.com/Bitcoin-com/rest.bitcoin.com/issues/330
+        return res.json({
+          error: 'Array too large.'
+        })
+      }
+
+      // stub response object
+      // const returnResponse = {
+      //   status: 100,
+      //   json: {
+      //     error: ''
+      //   }
+      // }
+
+      // Validate each txid in the array.
+      for (let i = 0; i < txids.length; i++) {
+        const txid = txids[i]
+
+        if (!txid || txid === '') {
+          res.status(400)
+          return res.json({ error: 'Encountered empty TXID' })
+        }
+
+        if (txid.length !== 64) {
+          res.status(400)
+          return res.json({
+            error: `parameter 1 must be of length 64 (not ${txid.length})`
+          })
+        }
+      }
+
+      // Loop through each txid and create an array of promises
+      const promises = txids.map(async txid =>
+        _this.getRawTransactionsFromNode(txid, verbose)
+      )
+
+      // Wait for all parallel promises to return.
+      const axiosResult = await _this.axios.all(promises)
+
+      res.status(200)
+      return res.json(axiosResult)
+    } catch (err) {
+      // Write out error to error log.
+      // logger.error(`Error in rawtransactions/getRawTransaction: `, err)
+      wlogger.error('Error in rawtransactions.ts/getRawTransactionBulk().', err)
+      return _this.errorHandler(err, res)
+    }
+  }
+
+  // Get a JSON object breakdown of transaction details.
+  // GET
+  /**
+   * @api {get} /rawtransactions/getRawTransaction/{txid}  Return the raw transaction data.
+   * @apiName Get Raw Transaction
+   * @apiGroup Raw Transaction
+   * @apiDescription return the raw transaction data. If verbose is 'true', returns an Object with information about 'txid'. If verbose is 'false' or omitted, returns a string that is serialized, hex-encoded data for 'txid'.
+   *
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v4/rawtransactions/getRawTransaction/fe28050b93faea61fa88c4c630f0e1f0a1c24d0082dd0e10d369e13212128f33?verbose=true" -H "accept: application/json"
+   *
+   *
+   */
+  async getRawTransactionSingle (req, res, next) {
+    try {
+      let verbose = 0
+      if (req.query.verbose === 'true') verbose = 1
+
+      const txid = req.params.txid
+      if (!txid || txid === '') {
+        res.status(400)
+        return res.json({ error: 'txid can not be empty' })
+      }
+
+      if (txid.length !== 64) {
+        res.status(400)
+        return res.json({
+          error: `parameter 1 must be of length 64 (not ${txid.length})`
+        })
+      }
+
+      const data = await _this.getRawTransactionsFromNode(txid, verbose)
+
+      return res.json(data)
+    } catch (err) {
+      // Write out error to error log.
+      // logger.error(`Error in rawtransactions/getRawTransaction: `, err)
+      wlogger.error(
+        'Error in rawtransactions.ts/getRawTransactionSingle().',
+        err
+      )
+
+      return _this.errorHandler(err, res)
+    }
+  }
+
+  // Transmit a raw transaction to the BCH network.
+  /**
+   * @api {post} /rawtransactions/sendRawTransaction  Send Bulk Raw Transactions.
+   * @apiName Send Bulk Raw Transactions
+   * @apiGroup Raw Transaction
+   * @apiDescription Submits multiple raw transaction (serialized, hex-encoded) to local node and network.
+   *
+   *
+   * @apiExample Example usage:
+   * curl -X POST "https://api.fullstack.cash/v4/rawtransactions/sendRawTransaction" -H "accept:application/json" -H "Content-Type: application/json" -d '{"hexes":["01000000013ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a000000006a4730440220540986d1c58d6e76f8f05501c520c38ce55393d0ed7ed3c3a82c69af04221232022058ea43ed6c05fec0eccce749a63332ed4525460105346f11108b9c26df93cd72012103083dfc5a0254613941ddc91af39ff90cd711cdcde03a87b144b883b524660c39ffffffff01807c814a000000001976a914d7e7c4e0b70eaa67ceff9d2823d1bbb9f6df9a5188ac00000000","01000000013ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a000000006a4730440220540986d1c58d6e76f8f05501c520c38ce55393d0ed7ed3c3a82c69af04221232022058ea43ed6c05fec0eccce749a63332ed4525460105346f11108b9c26df93cd72012103083dfc5a0254613941ddc91af39ff90cd711cdcde03a87b144b883b524660c39ffffffff01807c814a000000001976a914d7e7c4e0b70eaa67ceff9d2823d1bbb9f6df9a5188ac00000000"]}'
+   *
+   *
+   */
+  async sendRawTransactionBulk (req, res, next) {
+    try {
+      // Validation
+      const hexes = req.body.hexes
+
+      // Reject if input is not an array
+      if (!Array.isArray(hexes)) {
+        res.status(400)
+        return res.json({ error: 'hex must be an array' })
+      }
+
+      const options = _this.routeUtils.getAxiosOptions()
+
+      // Enforce array size rate limits
+      if (!_this.routeUtils.validateArraySize(req, hexes)) {
+        res.status(429) // https://github.com/Bitcoin-com/rest.bitcoin.com/issues/330
+        return res.json({
+          error: 'Array too large.'
+        })
+      }
+
+      // Validate each element
+      for (let i = 0; i < hexes.length; i++) {
+        const hex = hexes[i]
+
+        if (hex === '') {
+          res.status(400)
+          return res.json({
+            error: 'Encountered empty hex'
+          })
+        }
+      }
+
+      // Dev Note CT 1/31/2019:
+      // Sending the 'sendrawtrnasaction' RPC call to a full node in parallel will
+      // not work. Testing showed that the full node will return the same TXID for
+      // different TX hexes. I believe this is by design, to prevent double spends.
+      // In parallel, we are essentially asking the node to broadcast a new TX before
+      // it's finished broadcast the previous one. Serial execution is required.
+
+      // How to send TX hexes in parallel the WRONG WAY:
+      /*
+          // Collect an array of promises.
+          const promises = hexes.map(async (hex: any) => {
+            requestConfig.data.id = "sendrawtransaction"
+            requestConfig.data.method = "sendrawtransaction"
+            requestConfig.data.params = [hex]
+            return await BitboxHTTP(requestConfig)
+          })
+          // Wait for all parallel Insight requests to return.
+          const axiosResult: Array<any> = await axios.all(promises)
+          // Retrieve the data part of the result.
+          const result = axiosResult.map(x => x.data.result)
+          */
+
+      // Sending them serially.
+      const result = []
+      for (let i = 0; i < hexes.length; i++) {
+        const hex = hexes[i]
+
+        options.data.id = 'sendrawtransaction'
+        options.data.method = 'sendrawtransaction'
+        options.data.params = [hex]
+
+        const rpcResult = await _this.axios.request(options)
+
+        result.push(rpcResult.data.result)
+      }
+
+      res.status(200)
+      return res.json(result)
+    } catch (err) {
+      wlogger.error(
+        'Error in rawtransactions.ts/sendRawTransactionBulk().',
+        err
+      )
+      return _this.errorHandler(err, res)
+    }
+  }
+
+  // Transmit a raw transaction to the BCH network.
+  /**
+   * @api {get} /rawtransactions/sendRawTransaction/{hex}  Send Single Raw Transaction.
+   * @apiName Send Single Raw Transaction
+   * @apiGroup Raw Transaction
+   * @apiDescription Submits single raw transaction (serialized, hex-encoded) to local node and network.
+   *
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v4/rawtransactions/sendRawTransaction/01000000013ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a000000006a4730440220540986d1c58d6e76f8f05501c520c38ce55393d0ed7ed3c3a82c69af04221232022058ea43ed6c05fec0eccce749a63332ed4525460105346f11108b9c26df93cd72012103083dfc5a0254613941ddc91af39ff90cd711cdcde03a87b144b883b524660c39ffffffff01807c814a000000001976a914d7e7c4e0b70eaa67ceff9d2823d1bbb9f6df9a5188ac00000000" -H "accept: "
+   *
+   *
+   */
+  async sendRawTransactionSingle (req, res, next) {
+    try {
+      const hex = req.params.hex // URL parameter
+
+      // Reject if input is not an array or a string
+      if (typeof hex !== 'string') {
+        res.status(400)
+        return res.json({ error: 'hex must be a string' })
+      }
+
+      // Validation
+      if (hex === '') {
+        res.status(400)
+        return res.json({
+          error: 'Encountered empty hex'
+        })
+      }
+
+      const options = _this.routeUtils.getAxiosOptions()
+
+      // RPC call
+      options.data.id = 'sendrawtransaction'
+      options.data.method = 'sendrawtransaction'
+      options.data.params = [hex]
+
+      const rpcResult = await _this.axios.request(options)
+
+      const result = rpcResult.data.result
+
+      res.status(200)
+      return res.json(result)
+    } catch (err) {
+      wlogger.error(
+        'Error in rawtransactions.ts/sendRawTransactionSingle().',
+        err
+      )
+      return _this.errorHandler(err, res)
+    }
+  }
+}
+
+module.exports = RawTransactions

src/routes/v4/health-check.js

@@ -0,0 +1,16 @@
+/*
+  This health-check API can be used to test the server for aliveness and
+  readiness.
+*/
+
+'use strict'
+
+const express = require('express')
+const router = express.Router()
+
+/* GET home page. */
+router.get('/', (req, res, next) => {
+  res.json({ status: true })
+})
+
+module.exports = router

src/routes/v4/ninsight.js

@@ -0,0 +1,32 @@
+/*
+  A library for interacting with the Bitcoin.com ninsight (not Insight) indexer.
+*/
+
+'use strict'
+
+const express = require('express')
+// const axios = require('axios')
+// const routeUtils = require('./route-utils')
+// const wlogger = require('../../util/winston-logging')
+
+const router = express.Router()
+
+// const BCHJS = require('@psf/bch-js')
+// const bchjs = new BCHJS()
+
+// let _this
+
+class Ninsight {
+  constructor () {
+    // _this = this
+
+    this.router = router
+    this.router.get('/', this.root)
+  }
+
+  root (req, res, next) {
+    return res.json({ status: 'ninsight' })
+  }
+}
+
+module.exports = Ninsight

src/routes/v4/price.js

@@ -0,0 +1,155 @@
+/*
+  This price route is really just a wrapper for another API price endpoint.
+  The main reason for hosting this price wrapper is so that the price can
+  be accessible over Tor. Tor is typically blocked by other REST API servers.
+*/
+
+'use strict'
+
+const express = require('express')
+const axios = require('axios')
+const wlogger = require('../../util/winston-logging')
+const util = require('util')
+
+const RouteUtils = require('../../util/route-utils')
+const routeUtils = new RouteUtils()
+
+let _this // Global context for 'this' instance of the Class.
+
+class Price {
+  constructor () {
+    _this = this
+
+    this.axios = axios
+    this.routeUtils = routeUtils
+
+    this.priceUrl = 'https://api.coinbase.com/v2/exchange-rates?currency=BCH'
+    this.coinexPriceUrl =
+      'https://api.coinex.com/v1/market/ticker?market=bchausdt'
+
+    this.router = express.Router()
+    this.router.get('/', _this.root)
+    this.router.get('/usd', _this.getUSD)
+    this.router.get('/rates', _this.getBCHRate)
+    this.router.get('/bchausd', _this.getBCHAUSD)
+  }
+
+  // DRY error handler.
+  errorHandler (err, res) {
+    // Attempt to decode the error message.
+    const { msg, status } = _this.routeUtils.decodeError(err)
+    if (msg) {
+      res.status(status)
+      return res.json({ error: msg })
+    }
+
+    res.status(500)
+    return res.json({ error: util.inspect(err) })
+  }
+
+  // Root API endpoint. Simply acknowledges that it exists.
+  root (req, res, next) {
+    return res.json({ status: 'price' })
+  }
+
+  /**
+   * @api {get} /price/usd Get the USD price of BCH
+   * @apiName Get the USD price of BCH
+   * @apiGroup Price
+   * @apiDescription Get the USD price of BCH from Coinbase.
+   *
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v4/price/usd" -H "accept: application/json"
+   *
+   */
+  async getUSD (req, res, next) {
+    try {
+      // Request options
+      const opt = {
+        method: 'get',
+        baseURL: _this.priceUrl,
+        timeout: 15000
+      }
+
+      const response = await axios.request(opt)
+      // console.log(`response.data: ${JSON.stringify(response.data, null, 2)}`)
+
+      return res.json({ usd: Number(response.data.data.rates.USD) })
+    } catch (err) {
+      // Write out error to error log.
+      wlogger.error('Error in price.js/getUSD().', err)
+
+      return _this.errorHandler(err, res)
+    }
+  }
+
+  /**
+   * @api {get} /price/usd Get rates for several different currencies
+   * @apiName Get rates for several different currencies
+   * @apiGroup Price
+   * @apiDescription Get rates for several different currencies from Coinbase.
+   *
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v4/price/rates" -H "accept: application/json"
+   *
+   */
+  // Get rates for several different currencies
+  async getBCHRate (req, res, next) {
+    try {
+      // Request options
+      const opt = {
+        method: 'get',
+        baseURL: _this.priceUrl,
+        timeout: 15000
+      }
+
+      const response = await axios.request(opt)
+      // console.log(`response.data: ${JSON.stringify(response.data, null, 2)}`)
+
+      return res.json(response.data.data.rates)
+    } catch (err) {
+      // Write out error to error log.
+      wlogger.error('Error in price.js/getUSD().', err)
+
+      return _this.errorHandler(err, res)
+    }
+  }
+
+  /**
+   * @api {get} /price/bchausd Get the USD price of BCHA
+   * @apiName Get the USD price of BCHA
+   * @apiGroup Price
+   * @apiDescription Get the USD price of BCHA from Coinex.
+   *
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v4/price/bchausd" -H "accept: application/json"
+   *
+   */
+  async getBCHAUSD (req, res, next) {
+    try {
+      // Request options
+      const opt = {
+        method: 'get',
+        baseURL: _this.coinexPriceUrl,
+        timeout: 15000
+      }
+
+      const response = await axios.request(opt)
+      // console.log(`response.data: ${JSON.stringify(response.data, null, 2)}`)
+
+      const price = Number(response.data.data.ticker.last)
+
+      return res.json({ usd: price })
+    } catch (err) {
+      // Write out error to error log.
+      wlogger.error('Error in price.js/getBCHAUSD().', err)
+
+      return _this.errorHandler(err, res)
+    }
+  }
+}
+
+module.exports = Price

src/routes/v4/route-utils.js

@@ -0,0 +1,183 @@
+/*
+  A private library of utility functions used by several different routes.
+*/
+
+'use strict'
+
+const axios = require('axios')
+const wlogger = require('../../util/winston-logging')
+
+const util = require('util')
+util.inspect.defaultOptions = { depth: 1 }
+
+const BCHJS = require('@psf/bch-js')
+const bchjs = new BCHJS()
+
+module.exports = {
+  validateNetwork, // Prevents a common user error
+  setEnvVars, // Allows RPC variables to be set dynamically based on changing env vars.
+  decodeError, // Extract and interpret error messages.
+  validateArraySize, // Ensure the passed array meets rate limiting requirements.
+  getAxiosOptions
+}
+
+// This function expects the Request Express.js object and an array as input.
+// The array is then validated against freemium and pro-tier rate limiting
+// requirements. A boolean is returned to indicate if the array size if valid
+// or not.
+function validateArraySize (req, array) {
+  const FREEMIUM_INPUT_SIZE = 20
+  const PRO_INPUT_SIZE = 20
+
+  if (req.locals && req.locals.proLimit) {
+    if (array.length <= PRO_INPUT_SIZE) return true
+  } else if (array.length <= FREEMIUM_INPUT_SIZE) {
+    return true
+  }
+
+  return false
+}
+
+// Returns true if user-provided cash address matches the correct network,
+// mainnet or testnet. If NETWORK env var is not defined, it returns false.
+// This prevent a common user-error issue that is easy to make: passing a
+// testnet address into rest.bitcoin.com or passing a mainnet address into
+// trest.bitcoin.com.
+function validateNetwork (addr) {
+  try {
+    const network = process.env.NETWORK
+
+    // Return false if NETWORK is not defined.
+    if (!network || network === '') {
+      console.log('Warning: NETWORK environment variable is not defined!')
+      return false
+    }
+
+    // Convert the user-provided address to a cashaddress, for easy detection
+    // of the intended network.
+    const cashAddr = bchjs.Address.toCashAddress(addr)
+
+    // Return true if the network and address both match testnet
+    const addrIsTest = bchjs.Address.isTestnetAddress(cashAddr)
+    if (network === 'testnet' && addrIsTest) return true
+
+    // Return true if the network and address both match mainnet
+    const addrIsMain = bchjs.Address.isMainnetAddress(cashAddr)
+    if (network === 'mainnet' && addrIsMain) return true
+
+    return false
+  } catch (err) {
+    wlogger.error('Error in validateNetwork()')
+    return false
+  }
+}
+
+// Dynamically set these based on env vars. Allows unit testing.
+function setEnvVars () {
+  const BitboxHTTP = axios.create({
+    baseURL: process.env.RPC_BASEURL,
+    timeout: 15000
+  })
+  const username = process.env.RPC_USERNAME
+  const password = process.env.RPC_PASSWORD
+
+  const requestConfig = {
+    method: 'post',
+    auth: {
+      username: username,
+      password: password
+    },
+    data: {
+      jsonrpc: '1.0'
+    }
+  }
+
+  return { BitboxHTTP, username, password, requestConfig }
+}
+
+// Axios options used when calling axios.post() to talk with a full node.
+function getAxiosOptions () {
+  return {
+    method: 'post',
+    baseURL: process.env.RPC_BASEURL,
+    timeout: 15000,
+    auth: {
+      username: process.env.RPC_USERNAME,
+      password: process.env.RPC_PASSWORD
+    },
+    data: {
+      jsonrpc: '1.0'
+    }
+  }
+}
+
+// Error messages returned by a full node can be burried pretty deep inside the
+// error object returned by Axios. This function attempts to extract and interpret
+// error messages.
+// Returns an object. If successful, obj.msg is a string.
+// If there is a failure, obj.msg is false.
+function decodeError (err) {
+  try {
+    // Attempt to extract the full node error message.
+    if (
+      err.response &&
+      err.response.data &&
+      err.response.data.error &&
+      err.response.data.error.message
+    ) {
+      return { msg: err.response.data.error.message, status: 400 }
+    }
+
+    // Attempt to extract the Insight error message
+    if (err.response && err.response.data) {
+      return { msg: err.response.data, status: err.response.status }
+    }
+
+    // console.log(`err.message: ${err.message}`)
+    // console.log(`err: `, err)
+
+    // Attempt to detect a network connection error.
+    if (err.message && err.message.indexOf('ENOTFOUND') > -1) {
+      return {
+        msg:
+          'Network error: Could not communicate with full node or other external service.',
+        status: 503
+      }
+    }
+
+    // Different kind of network error
+    if (err.message && err.message.indexOf('ENETUNREACH') > -1) {
+      return {
+        msg:
+          'Network error: Could not communicate with full node or other external service.',
+        status: 503
+      }
+    }
+
+    // Different kind of network error
+    if (err.message && err.message.indexOf('EAI_AGAIN') > -1) {
+      return {
+        msg:
+          'Network error: Could not communicate with full node or other external service.',
+        status: 503
+      }
+    }
+
+    // Axios timeout (aborted) error, or service is down (connection refused).
+    if (
+      err.code &&
+      (err.code === 'ECONNABORTED' || err.code === 'ECONNREFUSED')
+    ) {
+      return {
+        msg:
+          'Network error: Could not communicate with full node or other external service.',
+        status: 503
+      }
+    }
+
+    return { msg: false, status: 500 }
+  } catch (err) {
+    wlogger.error('unhandled error in route-utils.js/decodeError(): ', err)
+    return { msg: false, status: 500 }
+  }
+}

src/routes/v4/services/slpdb.js

@@ -0,0 +1,351 @@
+const axios = require('axios')
+
+const SLPSDK = require('@psf/bch-js')
+const SLP = new SLPSDK()
+
+class Slpdb {
+  // Gets transaction history for all tokens for an address. Can also specify
+  // block height, but defaults to 0.
+  async getHistoricalSlpTransactions (addressList, fromBlock = 0) {
+    // Build SLPDB or query from addressList
+    const orQueryArray = []
+    for (const address of addressList) {
+      const cashAddress = SLP.SLP.Address.toCashAddress(address)
+      const slpAddress = SLP.SLP.Address.toSLPAddress(address)
+
+      const cashQuery = {
+        'in.e.a': cashAddress.slice(12)
+      }
+      const slpQuery = {
+        'slp.detail.outputs.address': slpAddress
+      }
+
+      orQueryArray.push(cashQuery)
+      orQueryArray.push(slpQuery)
+    }
+
+    const query = {
+      v: 3,
+      q: {
+        find: {
+          db: ['c', 'u'],
+          $query: {
+            $or: orQueryArray,
+            'slp.valid': true,
+            'blk.i': {
+              $not: {
+                $lte: fromBlock
+              }
+            }
+          },
+          $orderby: {
+            'blk.i': -1
+          }
+        },
+        project: {
+          _id: 0,
+          'tx.h': 1,
+          'in.i': 1,
+          'in.e': 1,
+          'out.e': 1,
+          'out.a': 1,
+          'slp.detail': 1,
+          blk: 1
+        },
+        limit: 500
+      }
+    }
+
+    const result = await this.runQuery(query)
+    // console.log(`result.data: ${JSON.stringify(result.data, null, 2)}`)
+
+    let transactions = []
+
+    // Add confirmed transactions
+    if (result.data && result.data.c) {
+      transactions = transactions.concat(result.data.c)
+    }
+
+    // Add unconfirmed transactions
+    if (result.data && result.data.u) {
+      transactions = transactions.concat(result.data.u)
+    }
+
+    return transactions
+  }
+
+  async getTokenStats (tokenId) {
+    const [
+      totalMinted,
+      totalBurned,
+      tokenDetails,
+      circulatingSupply
+    ] = await Promise.all([
+      this.getTotalMinted(tokenId),
+      this.getTotalBurned(tokenId),
+      this.getTokenDetails(tokenId),
+      this.getTotalCirculating(tokenId)
+    ])
+
+    tokenDetails.totalMinted = tokenDetails.initialTokenQty + totalMinted
+    tokenDetails.totalBurned = totalBurned
+
+    // tokenDetails.circulatingSupply =
+    //   tokenDetails.totalMinted - tokenDetails.totalBurned
+    tokenDetails.circulatingSupply = circulatingSupply
+
+    return tokenDetails
+  }
+
+  generateCredentials () {
+    // Generate the Basic Authentication header for a private instance of SLPDB.
+    const SLPDB_PASS = process.env.SLPDB_PASS
+      ? process.env.SLPDB_PASS
+      : 'BITBOX'
+    const username = 'BITBOX'
+    const password = SLPDB_PASS
+    const combined = `${username}:${password}`
+    var base64Credential = Buffer.from(combined).toString('base64')
+    var readyCredential = `Basic ${base64Credential}`
+
+    const options = {
+      headers: {
+        authorization: readyCredential,
+        timeout: 30000
+      }
+    }
+
+    return options
+  }
+
+  async runQuery (query) {
+    const queryString = JSON.stringify(query)
+    const queryBase64 = Buffer.from(queryString).toString('base64')
+    const url = `${process.env.SLPDB_URL}q/${queryBase64}`
+
+    const options = this.generateCredentials()
+
+    const response = await axios.get(url, options)
+    return response
+  }
+
+  async getTotalMinted (tokenId) {
+    const query = {
+      v: 3,
+      q: {
+        db: ['g'],
+        aggregate: [
+          {
+            $match: {
+              'tokenDetails.tokenIdHex': tokenId,
+              'graphTxn.outputs.status': {
+                $in: [
+                  'BATON_SPENT_IN_MINT',
+                  'BATON_UNSPENT',
+                  'BATON_SPENT_NOT_IN_MINT'
+                ]
+              }
+            }
+          },
+          {
+            $unwind: '$graphTxn.outputs'
+          },
+          {
+            $group: {
+              _id: null,
+              count: {
+                $sum: '$graphTxn.outputs.slpAmount'
+              }
+            }
+          }
+        ],
+        limit: 1
+      }
+    }
+
+    const result = await this.runQuery(query)
+
+    if (!result.data.g.length) {
+      return 0
+    }
+
+    return parseFloat(result.data.g[0].count)
+  }
+
+  async getTotalCirculating (tokenId) {
+    const query = {
+      v: 3,
+      q: {
+        db: ['g'],
+        aggregate: [
+          {
+            $match: {
+              'tokenDetails.tokenIdHex': tokenId,
+              'graphTxn.outputs': {
+                $elemMatch: {
+                  status: 'UNSPENT',
+                  slpAmount: { $gte: 0 }
+                }
+              }
+            }
+          },
+          { $unwind: '$graphTxn.outputs' },
+          {
+            $match: {
+              'graphTxn.outputs.status': 'UNSPENT',
+              'graphTxn.outputs.slpAmount': { $gte: 0 }
+            }
+          },
+          {
+            $group: {
+              _id: null,
+              circulating_supply: {
+                $sum: '$graphTxn.outputs.slpAmount'
+              }
+            }
+          }
+        ],
+        limit: 100000
+      }
+    }
+
+    const result = await this.runQuery(query)
+    // console.log(`result.data: ${JSON.stringify(result.data, null, 2)}`)
+
+    if (!result.data.g.length) {
+      return 0
+    }
+
+    return parseFloat(result.data.g[0].circulating_supply)
+  }
+
+  async getTotalBurned (tokenId) {
+    const query = {
+      v: 3,
+      q: {
+        db: ['g'],
+        aggregate: [
+          {
+            $match: {
+              'tokenDetails.tokenIdHex': tokenId,
+              'graphTxn.outputs.status': {
+                $in: [
+                  'SPENT_NON_SLP',
+                  'BATON_SPENT_INVALID_SLP',
+                  'SPENT_INVALID_SLP',
+                  'BATON_SPENT_NON_SLP',
+                  'MISSING_BCH_VOUT',
+                  'BATON_MISSING_BCH_VOUT',
+                  'BATON_SPENT_NOT_IN_MINT',
+                  'EXCESS_INPUT_BURNED'
+                ]
+              }
+            }
+          },
+          {
+            $unwind: '$graphTxn.outputs'
+          },
+          {
+            $match: {
+              'graphTxn.outputs.status': {
+                $in: [
+                  'SPENT_NON_SLP',
+                  'BATON_SPENT_INVALID_SLP',
+                  'SPENT_INVALID_SLP',
+                  'BATON_SPENT_NON_SLP',
+                  'MISSING_BCH_VOUT',
+                  'BATON_MISSING_BCH_VOUT',
+                  'BATON_SPENT_NOT_IN_MINT',
+                  'EXCESS_INPUT_BURNED'
+                ]
+              }
+            }
+          },
+          {
+            $group: {
+              _id: null,
+              count: {
+                $sum: '$graphTxn.outputs.slpAmount'
+              }
+            }
+          }
+        ],
+        limit: 1
+      }
+    }
+
+    const result = await this.runQuery(query)
+
+    if (!result.data.g.length) {
+      return 0
+    }
+
+    return parseFloat(result.data.g[0].count)
+  }
+
+  async getTokenDetails (tokenId) {
+    const query = {
+      v: 3,
+      q: {
+        db: ['t'],
+        find: {
+          $query: {
+            'tokenDetails.tokenIdHex': tokenId
+          }
+        },
+        project: { tokenDetails: 1, tokenStats: 1, _id: 0 },
+        limit: 1
+      }
+    }
+
+    const result = await this.runQuery(query)
+
+    if (!result.data.t.length) {
+      throw new Error('Token could not be found')
+    }
+
+    const token = this.formatTokenOutput(result.data.t[0])
+
+    return token
+  }
+
+  formatTokenOutput (token) {
+    // console.log(`token: ${JSON.stringify(token, null, 2)}`)
+
+    token.tokenDetails.id = token.tokenDetails.tokenIdHex
+    delete token.tokenDetails.tokenIdHex
+    token.tokenDetails.documentHash = token.tokenDetails.documentSha256Hex
+    delete token.tokenDetails.documentSha256Hex
+    token.tokenDetails.initialTokenQty = parseFloat(
+      token.tokenDetails.genesisOrMintQuantity
+    )
+    delete token.tokenDetails.genesisOrMintQuantity
+    delete token.tokenDetails.transactionType
+    delete token.tokenDetails.batonVout
+    delete token.tokenDetails.sendOutputs
+
+    token.tokenDetails.blockCreated = token.tokenStats.block_created
+    token.tokenDetails.blockLastActiveSend =
+      token.tokenStats.block_last_active_send
+    token.tokenDetails.blockLastActiveMint =
+      token.tokenStats.block_last_active_mint
+    token.tokenDetails.txnsSinceGenesis =
+      token.tokenStats.qty_valid_txns_since_genesis
+    token.tokenDetails.validAddresses =
+      token.tokenStats.qty_valid_token_addresses
+    token.tokenDetails.mintingBatonStatus =
+      token.tokenStats.minting_baton_status
+
+    delete token.tokenStats.block_last_active_send
+    delete token.tokenStats.block_last_active_mint
+    delete token.tokenStats.qty_valid_txns_since_genesis
+    delete token.tokenStats.qty_valid_token_addresses
+
+    token.tokenDetails.timestampUnix = token.tokenDetails.timestamp_unix
+    delete token.tokenDetails.timestamp_unix
+
+    return token.tokenDetails
+  }
+}
+
+module.exports = Slpdb

src/routes/v4/util.js

@@ -0,0 +1,604 @@
+'use strict'
+
+const express = require('express')
+const router = express.Router()
+const axios = require('axios')
+
+const routeUtils = require('./route-utils')
+const wlogger = require('../../util/winston-logging')
+const Blockbook = require('./blockbook')
+const blockbook = new Blockbook()
+
+const util = require('util')
+util.inspect.defaultOptions = { depth: 1 }
+
+const BCHJS = require('@psf/bch-js')
+const bchjs = new BCHJS()
+// const BCHJS_TESTNET = 'https://testnet.bchjs.cash/v4/'
+
+// const bchjsHTTP = axios.create({
+//   baseURL: process.env.RPC_BASEURL
+// })
+
+// const username = process.env.RPC_USERNAME
+// const password = process.env.RPC_PASSWORD
+
+// const requestConfig = {
+//   method: 'post',
+//   auth: {
+//     username: username,
+//     password: password
+//   },
+//   data: {
+//     jsonrpc: '1.0'
+//   }
+// }
+
+let _this
+
+class UtilRoute {
+  constructor () {
+    this.bchjs = bchjs
+    this.blockbook = blockbook
+
+    _this = this
+  }
+
+  root (req, res, next) {
+    return res.json({ status: 'util' })
+  }
+
+  /**
+   * @api {get} /util/validateAddress/{address}  Get information about single bitcoin cash address.
+   * @apiName Information about single bitcoin cash address
+   * @apiGroup Util
+   * @apiDescription Returns information about single bitcoin cash address.
+   *
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v4/util/validateAddress/bitcoincash:qzs02v05l7qs5s24srqju498qu55dwuj0cx5ehjm2c" -H "accept: application/json"
+   *
+   *
+   */
+  async validateAddressSingle (req, res, next) {
+    try {
+      const address = req.params.address
+      if (!address || address === '') {
+        res.status(400)
+        return res.json({ error: 'address can not be empty' })
+      }
+
+      const {
+        BitboxHTTP,
+        // username,
+        // password,
+        requestConfig
+      } = routeUtils.setEnvVars()
+
+      requestConfig.data.id = 'validateaddress'
+      requestConfig.data.method = 'validateaddress'
+      requestConfig.data.params = [address]
+
+      const response = await BitboxHTTP(requestConfig)
+
+      return res.json(response.data.result)
+    } catch (err) {
+      // Attempt to decode the error message.
+      const { msg, status } = routeUtils.decodeError(err)
+      if (msg) {
+        res.status(status)
+        return res.json({ error: msg })
+      }
+
+      wlogger.error('Error in util.ts/validateAddressSingle().', err)
+
+      res.status(500)
+      return res.json({ error: util.inspect(err) })
+    }
+  }
+
+  /**
+   * @api {post} /util/validateAddress  Get information about bulk bitcoin cash addresses..
+   * @apiName Information about bulk bitcoin cash addresses.
+   * @apiGroup Util
+   * @apiDescription Returns information about bulk bitcoin cash addresses..
+   *
+   *
+   * @apiExample Example usage:
+   * curl -X POST "https://api.fullstack.cash/v4/util/validateAddress" -H "accept: application/json" -H "Content-Type: application/json" -d '{"addresses":["bitcoincash:qzs02v05l7qs5s24srqju498qu55dwuj0cx5ehjm2c","bitcoincash:qrehqueqhw629p6e57994436w730t4rzasnly00ht0"]}'
+   * curl -X POST "https://api.fullstack.cash/v4/util/validateAddress" -H "accept: application/json" -H "Content-Type: application/json" -d '{"addresses":["bitcoincash:qzs02v05l7qs5s24srqju498qu55dwuj0cx5ehjm2c","bitcoincash:qrehqueqhw629p6e57994436w730t4rzasnly00ht0"],"from": 1, "to": 5}'
+   *
+   *
+   */
+  async validateAddressBulk (req, res, next) {
+    try {
+      const addresses = req.body.addresses
+
+      // Reject if addresses is not an array.
+      if (!Array.isArray(addresses)) {
+        res.status(400)
+        return res.json({
+          error: 'addresses needs to be an array. Use GET for single address.'
+        })
+      }
+
+      // Enforce array size rate limits
+      if (!routeUtils.validateArraySize(req, addresses)) {
+        res.status(429) // https://github.com/Bitcoin-com/rest.bitcoin.com/issues/330
+        return res.json({
+          error: 'Array too large.'
+        })
+      }
+
+      // Validate each element in the array.
+      for (let i = 0; i < addresses.length; i++) {
+        const address = addresses[i]
+
+        // Ensure the input is a valid BCH address.
+        try {
+          bchjs.Address.toLegacyAddress(address)
+        } catch (err) {
+          res.status(400)
+          return res.json({
+            error: `Invalid BCH address. Double check your address is valid: ${address}`
+          })
+        }
+
+        // Prevent a common user error. Ensure they are using the correct network address.
+        const networkIsValid = routeUtils.validateNetwork(address)
+        if (!networkIsValid) {
+          res.status(400)
+          return res.json({
+            error:
+              'Invalid network. Trying to use a testnet address on mainnet, or vice versa.'
+          })
+        }
+      }
+
+      wlogger.debug('Executing util/validate with these addresses: ', addresses)
+
+      const {
+        BitboxHTTP,
+        // username,
+        // password,
+        requestConfig
+      } = routeUtils.setEnvVars()
+
+      // Loop through each address and creates an array of requests to call in parallel
+      const promises = addresses.map(async address => {
+        requestConfig.data.id = 'validateaddress'
+        requestConfig.data.method = 'validateaddress'
+        requestConfig.data.params = [address]
+
+        return BitboxHTTP(requestConfig)
+      })
+
+      // Wait for all parallel Insight requests to return.
+      const axiosResult = await axios.all(promises)
+
+      // Retrieve the data part of the result.
+      const result = axiosResult.map(x => x.data.result)
+
+      res.status(200)
+      return res.json(result)
+    } catch (err) {
+      // Attempt to decode the error message.
+      const { msg, status } = routeUtils.decodeError(err)
+      if (msg) {
+        res.status(status)
+        return res.json({ error: msg })
+      }
+
+      wlogger.error('Error in util.ts/validateAddressSingle().', err)
+
+      res.status(500)
+      return res.json({ error: util.inspect(err) })
+    }
+  }
+
+  /**
+   * @api {post} /util/sweep  Sweep BCH and tokens
+   * @apiName Sweep BCH and tokens from a paper wallet
+   * @apiGroup Util
+   * @apiDescription This function can be used to check the BCH balance of a
+   * paper wallet. It can also be used to sweep BCH and tokens from a paper
+   * wallet and send them to a destination address.
+   *
+   * Note: It does not yet support multiple token classes on the same paper wallet.
+   *
+   *
+   * @apiExample Example usage:
+   * curl -X POST "https://api.fullstack.cash/v4/util/sweep" -H "accept: application/json" -H "Content-Type: application/json" -d '{"wif":"Kz52sdXLAiKtH82iAFRi6aTZanWtW5Eyv37KWdpY6tTv7pjoHste", "balanceOnly": true}'
+   * curl -X POST "https://api.fullstack.cash/v4/util/sweep" -H "accept: application/json" -H "Content-Type: application/json" -d '{"wif":"Kz52sdXLAiKtH82iAFRi6aTZanWtW5Eyv37KWdpY6tTv7pjoHste", "toAddr": "bitcoincash:qpt8m4kqu963geedyrur6pdggqmv5kxwnq0rn322qu"}'
+   *
+   *
+   */
+
+  async sweepWif (req, res, next) {
+    try {
+      // Validate input
+      const wif = req.body.wif
+      const toAddr = req.body.toAddr
+      const balanceOnly = req.body.balanceOnly
+
+      if (typeof wif !== 'string' || wif.length !== 52) {
+        res.status(400)
+        return res.json({
+          error: 'WIF needs to a proper compressed WIF starting with K or L'
+        })
+      }
+
+      if (!balanceOnly) {
+        // Only throw error if balanceOnly is false or undefined.
+        if (!toAddr || toAddr === '') {
+          res.status(400)
+          return res.json({ error: 'address can not be empty' })
+        }
+      }
+
+      wlogger.debug('Executing util/sweepWif with this address: ', toAddr)
+
+      // Generate a private and public key pair from the WIF.
+      const ecPair = bchjs.ECPair.fromWIF(wif)
+      const fromAddr = bchjs.ECPair.toCashAddress(ecPair)
+
+      // Get a balance on the public address
+      const balances = await _this.blockbook.balanceFromBlockbook(fromAddr)
+      // console.log(`balances: ${JSON.stringify(balances, null, 2)}`)
+
+      // Total balance is the sum of the confirmed and unconfirmed balance.
+      const totalBalance =
+        Number(balances.balance) + Number(balances.unconfirmedBalance)
+
+      // Exit if balance is zero.
+      if (isNaN(totalBalance) || totalBalance === 0) {
+        res.status(422)
+        return res.json({ error: 'No balance found at BCH address.' })
+      }
+
+      // Exit if this is a balance-only call.
+      if (balanceOnly) {
+        res.status(200)
+        return res.json(totalBalance)
+      }
+
+      // Get all UTXOs help by the address.
+      const utxos = await _this.blockbook.utxosFromBlockbook(fromAddr)
+      // console.log(`utxos: ${JSON.stringify(utxos, null, 2)}`)
+
+      const tokenUtxos = []
+      const bchUtxos = []
+
+      // Exit if there are no UTXOs.
+      if (utxos.length === 0) {
+        res.status(422)
+        return res.json({ error: 'No utxos found.' })
+      }
+
+      // Figure out which UTXOs are associated with SLP tokens.
+      const isTokenUtxo = await _this.bchjs.SLP.Utils.tokenUtxoDetails(utxos)
+      // console.log(`isTokenUtxo: ${JSON.stringify(isTokenUtxo, null, 2)}`)
+
+      // Separate the bch and token UTXOs.
+      for (let i = 0; i < utxos.length; i++) {
+        // Filter based on isTokenUtxo.
+        if (!isTokenUtxo[i]) bchUtxos.push(utxos[i])
+        else tokenUtxos.push(isTokenUtxo[i])
+      }
+      // console.log(
+      //   `bchUtxos.length: ${bchUtxos.length}, tokenUtxos.length: ${tokenUtxos.length}`
+      // )
+
+      // Throw error if no BCH to move tokens.
+      if (bchUtxos.length === 0 && tokenUtxos.length > 0) {
+        res.status(422)
+        return res.json({
+          error:
+            'Tokens found, but no BCH UTXOs found. Add BCH to wallet to move tokens.'
+        })
+      }
+
+      // console.log(`tokenUtxos: ${JSON.stringify(tokenUtxos, null, 2)}`)
+
+      const options = {
+        ecPair,
+        utxos,
+        fromAddr,
+        toAddr,
+        bchUtxos,
+        tokenUtxos
+      }
+
+      let hex
+
+      // Choose the sweeping algorithm, based on if there are tokens or not.
+      if (tokenUtxos.length === 0) hex = await _this._sweepBCH(options)
+      else hex = await _this._sweepTokens(options, bchUtxos, tokenUtxos)
+      // console.log(`hex: ${hex}`)
+
+      // Throw error if there is more than one token class.
+
+      // Generate a transaction to move tokens and BCH.
+
+      // Broadcast the transaction.
+      const txid = _this.bchjs.RawTransactions.sendRawTransaction([hex])
+
+      res.status(200)
+      return res.json(txid)
+    } catch (err) {
+      // Attempt to decode the error message.
+      const { msg, status } = routeUtils.decodeError(err)
+      if (msg) {
+        res.status(status)
+        return res.json({ error: msg })
+      }
+
+      // Catch the specific case of multiple tokens.
+      if (
+        err.message &&
+        err.message.indexOf('Multiple token classes detected') > -1
+      ) {
+        res.status(422)
+        return res.json({ error: err.message })
+      }
+
+      wlogger.error('Error in util.js/sweepWif().', err)
+      console.error('Error in util.js/sweepWif().', err)
+
+      res.status(500)
+      return res.json({ error: err.message })
+    }
+  }
+
+  // Sweep BCH only from a private WIF.
+  async _sweepBCH (options) {
+    try {
+      // const wif = flags.wif
+      // const toAddr = flags.address
+
+      const ecPair = options.ecPair
+      const toAddr = options.toAddr
+
+      // const fromAddr = this.BITBOX.ECPair.toCashAddress(ecPair)
+      //
+      // // Get the UTXOs for that address.
+      // let utxos = await this.BITBOX.Blockbook.utxo(fromAddr)
+      // console.log(`utxos: ${JSON.stringify(utxos, null, 2)}`)
+
+      let utxos = options.utxos
+
+      // Ensure all utxos have the satoshis property.
+      utxos = utxos.map(x => {
+        x.satoshis = Number(x.value)
+        return x
+      })
+      // console.log(`utxos: ${JSON.stringify(utxos, null, 2)}`)
+
+      // instance of transaction builder
+      let transactionBuilder
+      if (options.testnet) {
+        transactionBuilder = new _this.bchjs.TransactionBuilder('testnet')
+      } else transactionBuilder = new _this.bchjs.TransactionBuilder()
+
+      let originalAmount = 0
+
+      // Loop through all UTXOs.
+      for (let i = 0; i < utxos.length; i++) {
+        const utxo = utxos[i]
+
+        originalAmount = originalAmount + utxo.satoshis
+
+        transactionBuilder.addInput(utxo.txid, utxo.vout)
+      }
+
+      if (originalAmount < 546) {
+        throw new Error(
+          'Original amount less than the dust limit. Not enough BCH to send.'
+        )
+      }
+
+      // get byte count to calculate fee. paying 1 sat/byte
+      const byteCount = _this.bchjs.BitcoinCash.getByteCount(
+        { P2PKH: utxos.length },
+        { P2PKH: 1 }
+      )
+      const fee = Math.ceil(1.1 * byteCount)
+
+      // amount to send to receiver. It's the original amount - 1 sat/byte for tx size
+      const sendAmount = originalAmount - fee
+
+      // add output w/ address and amount to send
+      transactionBuilder.addOutput(
+        _this.bchjs.Address.toLegacyAddress(toAddr),
+        sendAmount
+      )
+
+      // Loop through each input and sign
+      let redeemScript
+      for (var i = 0; i < utxos.length; i++) {
+        const utxo = utxos[i]
+
+        transactionBuilder.sign(
+          i,
+          ecPair,
+          redeemScript,
+          transactionBuilder.hashTypes.SIGHASH_ALL,
+          utxo.satoshis
+        )
+      }
+
+      // build tx
+      const tx = transactionBuilder.build()
+
+      // output rawhex
+      const hex = tx.toHex()
+      return hex
+    } catch (err) {
+      wlogger.error('Error in util.js/sweepBCH().')
+      throw err
+    }
+  }
+
+  // Sweep BCH and tokens from a WIF.
+  async _sweepTokens (options) {
+    try {
+      // const { ecPair, utxos, fromAddr, toAddr, bchUtxos, tokenUtxos } = options
+      const { ecPair, utxos, toAddr, bchUtxos, tokenUtxos } = options
+
+      // Input validation
+      if (!Array.isArray(bchUtxos) || bchUtxos.length === 0) {
+        throw new Error('bchUtxos need to be an array with one UTXO.')
+      }
+      if (!Array.isArray(tokenUtxos) || tokenUtxos.length === 0) {
+        throw new Error('tokenUtxos need to be an array with one UTXO.')
+      }
+
+      // if (flags.testnet)
+      //   this.BITBOX = new config.BCHLIB({ restURL: config.TESTNET_REST })
+
+      // console.log(`tokenUtxos: ${JSON.stringify(tokenUtxos, null, 2)}`)
+
+      // Ensure there is only one class of token in the wallet. Throw an error if
+      // there is more than one.
+      const tokenId = tokenUtxos[0].tokenId
+      const otherTokens = tokenUtxos.filter(x => x.tokenId !== tokenId)
+      if (otherTokens.length > 0) {
+        throw new Error(
+          'Multiple token classes detected. This function only supports a single class of token.'
+        )
+      }
+
+      // instance of transaction builder
+      let transactionBuilder
+      if (options.testnet) {
+        transactionBuilder = new _this.bchjs.TransactionBuilder('testnet')
+      } else transactionBuilder = new _this.bchjs.TransactionBuilder()
+
+      // Combine all the UTXOs into a single array.
+      const allUtxos = utxos
+      // console.log(`allUtxos: ${JSON.stringify(allUtxos, null, 2)}`)
+
+      // Loop through all UTXOs.
+      let originalAmount = 0
+      for (let i = 0; i < allUtxos.length; i++) {
+        const utxo = allUtxos[i]
+
+        originalAmount = originalAmount + utxo.satoshis
+
+        transactionBuilder.addInput(utxo.txid, utxo.vout)
+      }
+
+      if (originalAmount < 300) {
+        throw new Error(
+          'Not enough BCH to send. Send more BCH to the wallet to pay miner fees.'
+        )
+      }
+
+      // get byte count to calculate fee. paying 1 sat
+      // Note: This may not be totally accurate. Just guessing on the byteCount size.
+      // const byteCount = this.BITBOX.BitcoinCash.getByteCount(
+      //   { P2PKH: 3 },
+      //   { P2PKH: 5 }
+      // )
+      // //console.log(`byteCount: ${byteCount}`)
+      // const satoshisPerByte = 1.1
+      // const txFee = Math.floor(satoshisPerByte * byteCount)
+      // console.log(`txFee: ${txFee} satoshis\n`)
+      const txFee = 500
+
+      // amount to send back to the sending address. It's the original amount - 1 sat/byte for tx size
+      const remainder = originalAmount - txFee - 546
+      if (remainder < 1) {
+        throw new Error('Selected UTXO does not have enough satoshis')
+      }
+      // console.log(`remainder: ${remainder}`)
+
+      // Tally up the quantity of tokens
+      let tokenQty = 0
+      for (let i = 0; i < tokenUtxos.length; i++) {
+        tokenQty += tokenUtxos[i].tokenQty
+      }
+      // console.log(`tokenQty: ${tokenQty}`)
+
+      // Generate the OP_RETURN entry for an SLP SEND transaction.
+      // console.log(`Generating op-return.`)
+      const {
+        script,
+        outputs
+      } = _this.bchjs.SLP.TokenType1.generateSendOpReturn(tokenUtxos, tokenQty)
+      // console.log(`token outputs: ${outputs}`)
+
+      // Since we are sweeping all tokens from the WIF, there generateOpReturn()
+      // function should only compute 1 token output. If it returns 2, then there
+      // is something unexpected happening.
+      if (outputs > 1) {
+        throw new Error(
+          'More than one class of token detected. Sweep feature not supported.'
+        )
+      }
+
+      // Add OP_RETURN as first output.
+      const data = _this.bchjs.Script.encode(script)
+      transactionBuilder.addOutput(data, 0)
+
+      // Send dust transaction representing tokens being sent.
+      transactionBuilder.addOutput(
+        _this.bchjs.Address.toLegacyAddress(toAddr),
+        546
+      )
+
+      // Last output: send remaining BCH
+      transactionBuilder.addOutput(
+        _this.bchjs.Address.toLegacyAddress(toAddr),
+        remainder
+      )
+      // console.log(`utxo: ${JSON.stringify(utxo, null, 2)}`)
+
+      // Sign each UTXO being consumed.
+      let redeemScript
+      for (let i = 0; i < allUtxos.length; i++) {
+        const thisUtxo = allUtxos[i]
+        // console.log(`thisUtxo: ${JSON.stringify(thisUtxo, null, 2)}`)
+
+        transactionBuilder.sign(
+          i,
+          ecPair,
+          redeemScript,
+          transactionBuilder.hashTypes.SIGHASH_ALL,
+          thisUtxo.satoshis
+        )
+      }
+
+      // build tx
+      const tx = transactionBuilder.build()
+
+      // output rawhex
+      const hex = tx.toHex()
+      // console.log(`Transaction raw hex: `)
+      // console.log(hex)
+
+      return hex
+    } catch (err) {
+      wlogger.error('Error in util.js/sweepBCH().')
+      throw err
+    }
+  }
+}
+
+const utilRoute = new UtilRoute()
+
+router.get('/', utilRoute.root)
+router.get('/validateAddress/:address', utilRoute.validateAddressSingle)
+router.post('/validateAddress', utilRoute.validateAddressBulk)
+router.post('/sweep', utilRoute.sweepWif)
+
+module.exports = {
+  router,
+  // testableComponents: {
+  //   root,
+  //   validateAddressSingle,
+  //   validateAddressBulk,
+  //   sweepWif
+  // }
+  UtilRoute
+}

src/routes/v4/xpub.js

@@ -0,0 +1,80 @@
+/*
+  xpub route
+*/
+
+'use strict'
+
+const express = require('express')
+// const axios = require('axios')
+const routeUtils = require('./route-utils')
+const wlogger = require('../../util/winston-logging')
+
+// const router = express.Router()
+const router = express.Router()
+
+// Used for processing error messages before sending them to the user.
+const util = require('util')
+util.inspect.defaultOptions = { depth: 1 }
+
+const BCHJS = require('@psf/bch-js')
+const bchjs = new BCHJS()
+
+// Connect the route endpoints to their handler functions.
+router.get('/', root)
+router.get('/fromXPub/:xpub', fromXPubSingle)
+
+// Root API endpoint. Simply acknowledges that it exists.
+function root (req, res, next) {
+  return res.json({ status: 'address' })
+}
+
+async function fromXPubSingle (req, res, next) {
+  try {
+    const xpub = req.params.xpub
+    const hdPath = req.query.hdPath ? req.query.hdPath : '0'
+
+    if (!xpub || xpub === '') {
+      res.status(400)
+      return res.json({ error: 'xpub can not be empty' })
+    }
+
+    // Reject if xpub is an array.
+    if (Array.isArray(xpub)) {
+      res.status(400)
+      return res.json({
+        error: 'xpub can not be an array. Use POST for bulk upload.'
+      })
+    }
+
+    wlogger.debug('Executing address/fromXPub with this xpub: ', xpub)
+
+    const cashAddr = bchjs.Address.fromXPub(xpub, hdPath)
+    const legacyAddr = bchjs.Address.toLegacyAddress(cashAddr)
+    res.status(200)
+    return res.json({
+      cashAddress: cashAddr,
+      legacyAddress: legacyAddr
+    })
+  } catch (err) {
+    // Attempt to decode the error message.
+    const { msg, status } = routeUtils.decodeError(err)
+    if (msg) {
+      res.status(status)
+      return res.json({ error: msg })
+    }
+
+    // Write out error to error log.
+    wlogger.error('Error in address.ts/fromXPubSingle().', err)
+
+    res.status(500)
+    return res.json({ error: util.inspect(err) })
+  }
+}
+
+module.exports = {
+  router,
+  testableComponents: {
+    root,
+    fromXPubSingle
+  }
+}

start-dev-example.sh

@@ -8,6 +8,14 @@ export NETWORK=mainnet
 
 # SLPDB
 export SLPDB_URL=http://<SLPDB IP>:12300/
+export SLPDB_PASS=somelongpassword
+
+# Use the same address as SLPDB_URL if you don't have a separate whitelist server.
+export SLPDB_WHITELIST_URL=http://<SLPDB IP>:12300/
+
+# slp-api alternative SLP validator using slp-validate:
+# https://github.com/Permissionless-Software-Foundation/slp-api
+export SLP_API_URL=http://10.0.0.5:5001/
 
 # Blockbook
 export BLOCKBOOK_URL=https://<Blockbook IP>:9131/
@@ -23,9 +31,6 @@ export TOKENSECRET=somelongpassword
 # So that bch-api can call bch-js locally.
 export LOCAL_RESTURL=http://127.0.0.1:3000/v3/
 
-# slp-api alternative SLP validator.
-export SLP_API_URL=http://10.0.0.5:5001/
-
 # Basic Authentication password
 export PRO_PASS=somerandomepassword:someotherrandompassword:aThirdPassword
 

test/v3/a01-electrumx.js

@@ -42,7 +42,7 @@ function expectRouteError (res, result, expectedError, code = 400) {
   assert.equal(result.success, false)
 }
 
-describe('#ElectrumX Router', () => {
+describe('#Electrumx', () => {
   let req, res
   let sandbox
   const electrumxRoute = new ElecrumxRoute()

test/v3/blockchain.js

@@ -821,6 +821,7 @@ describe('#BlockchainRouter', () => {
       ])
     })
   })
+
   describe('getRawMempool()', () => {
     it('should throw 503 when network issues', async () => {
       // Save the existing RPC URL.
@@ -842,6 +843,7 @@ describe('#BlockchainRouter', () => {
         'Error message expected'
       )
     })
+
     it('returns proper error when downstream service stalls', async () => {
       // Mock the timeout error.
       sandbox.stub(uut.axios, 'request').throws({ code: 'ECONNABORTED' })
@@ -856,6 +858,7 @@ describe('#BlockchainRouter', () => {
         'Error message expected'
       )
     })
+
     it('returns proper error when downstream service is down', async () => {
       // Mock the timeout error.
       sandbox.stub(uut.axios, 'request').throws({ code: 'ECONNREFUSED' })
@@ -871,7 +874,7 @@ describe('#BlockchainRouter', () => {
       )
     })
 
-    it('should GET /getMempoolInfo', async () => {
+    it('should GET /getRawMempool', async () => {
       // Mock the RPC call for unit tests.
       if (process.env.TEST === 'unit') {
         sandbox
@@ -886,6 +889,7 @@ describe('#BlockchainRouter', () => {
       // Not sure what other assertions should be made here.
     })
   })
+
   describe('getMempoolEntrySingle()', () => {
     it('should throw 400 if txid is empty', async () => {
       const result = await uut.getMempoolEntrySingle(req, res)

test/v3/integration/price.js

@@ -4,7 +4,7 @@
 
 'use strict'
 
-// const assert = require('chai').assert
+const assert = require('chai').assert
 // const axios = require('axios')
 
 // Used for debugging.
@@ -29,6 +29,17 @@ describe('#price', () => {
     it('should get the USD price', async () => {
       const result = await price.getUSD(req, res)
       console.log(`result: ${util.inspect(result)}`)
+
+      assert.isNumber(result.usd)
+    })
+  })
+
+  describe('#getBCHAUSD', () => {
+    it('should get the USD price of BCHA', async () => {
+      const result = await price.getBCHAUSD(req, res)
+      console.log(`result: ${util.inspect(result)}`)
+
+      assert.isNumber(result.usd)
     })
   })
 })

test/v3/mocks/price-mock.js

@@ -216,6 +216,26 @@ const mockCoinbaseFeed = {
   }
 }
 
-module.exports = {
-  mockCoinbaseFeed
+const mockCoinexFeed = {
+  code: 0,
+  data: {
+    date: 1605649499848,
+    ticker: {
+      vol: '26717.39062407',
+      low: '10.4000',
+      open: '11.8000',
+      high: '19.0029',
+      last: '18.5000',
+      buy: '18.0100',
+      buy_amount: '200.00000000',
+      sell: '18.5000',
+      sell_amount: '47.89580474'
+    }
+  },
+  message: 'OK'
+}
+
+module.exports = {
+  mockCoinbaseFeed,
+  mockCoinexFeed
 }

test/v3/price.js

@@ -211,4 +211,70 @@ describe('#PriceRouter', () => {
       assert.property(result, 'error')
     })
   })
+
+  describe('#getBCHAUSD', () => {
+    // const getNetworkInfo = controlRoute.testableComponents.getNetworkInfo
+
+    it('should throw 500 when network issues', async () => {
+      uut.coinexPriceUrl = 'http://fakeurl/api/'
+
+      await uut.getBCHAUSD(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.isAbove(
+        res.statusCode,
+        499,
+        'HTTP status code 500 or greater expected.'
+      )
+      // console.log(res)
+      assert.include(
+        res.output.error,
+        'Network error: Could not communicate with full node or other external service'
+      )
+    })
+
+    it('returns proper error when downstream service stalls', async () => {
+      // Mock the timeout error.
+      sandbox.stub(uut.axios, 'request').throws({ code: 'ECONNABORTED' })
+
+      const result = await uut.getBCHAUSD(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.isAbove(res.statusCode, 499, 'HTTP status code 503 expected.')
+      assert.include(
+        result.error,
+        'Could not communicate with full node',
+        'Error message expected'
+      )
+    })
+
+    it('returns proper error when downstream service is down', async () => {
+      // Mock the timeout error.
+      sandbox.stub(uut.axios, 'request').throws({ code: 'ECONNREFUSED' })
+
+      const result = await uut.getBCHAUSD(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.isAbove(res.statusCode, 499, 'HTTP status code 503 expected.')
+      assert.include(
+        result.error,
+        'Could not communicate with full node',
+        'Error message expected'
+      )
+    })
+
+    it('should get the USD price of BCH', async () => {
+      // Mock the RPC call for unit tests.
+      if (process.env.TEST === 'unit') {
+        sandbox
+          .stub(uut.axios, 'request')
+          .resolves({ data: mockData.mockCoinexFeed })
+      }
+
+      const result = await uut.getBCHAUSD(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.isNumber(result.usd)
+    })
+  })
 })

test/v4/control.js

@@ -0,0 +1,164 @@
+/*
+  TESTS FOR THE CONTROL.JS LIBRARY
+
+  This test file uses the environment variable TEST to switch between unit
+  and integration tests. By default, TEST is set to 'unit'. Set this variable
+  to 'integration' to run the tests against BCH mainnet.
+
+*/
+
+'use strict'
+
+const chai = require('chai')
+const assert = chai.assert
+const ControlRoute = require('../../src/routes/v4/full-node/control')
+const uut = new ControlRoute()
+const sinon = require('sinon')
+
+let originalEnvVars // Used during transition from integration to unit tests.
+
+// Mocking data.
+const { mockReq, mockRes } = require('./mocks/express-mocks')
+const mockData = require('./mocks/control-mock')
+
+// Used for debugging.
+const util = require('util')
+util.inspect.defaultOptions = { depth: 1 }
+
+describe('#ControlRouter', () => {
+  let req, res
+  let sandbox
+
+  before(() => {
+    // Save existing environment variables.
+    originalEnvVars = {
+      BITCOINCOM_BASEURL: process.env.BITCOINCOM_BASEURL,
+      RPC_BASEURL: process.env.RPC_BASEURL,
+      RPC_USERNAME: process.env.RPC_USERNAME,
+      RPC_PASSWORD: process.env.RPC_PASSWORD
+    }
+
+    // Set default environment variables for unit tests.
+  })
+
+  // Setup the mocks before each test.
+  beforeEach(() => {
+    // Mock the req and res objects used by Express routes.
+    req = mockReq
+    res = mockRes
+
+    // Explicitly reset the parmas and body.
+    req.params = {}
+    req.body = {}
+    req.query = {}
+
+    sandbox = sinon.createSandbox()
+  })
+
+  afterEach(() => {
+    // Restore Sandbox
+    sandbox.restore()
+  })
+
+  after(() => {
+    // Restore any pre-existing environment variables.
+    process.env.BITCOINCOM_BASEURL = originalEnvVars.BITCOINCOM_BASEURL
+    process.env.RPC_BASEURL = originalEnvVars.RPC_BASEURL
+    process.env.RPC_USERNAME = originalEnvVars.RPC_USERNAME
+    process.env.RPC_PASSWORD = originalEnvVars.RPC_PASSWORD
+  })
+
+  describe('#root', async () => {
+    // root route handler.
+    // const root = controlRoute.testableComponents.root
+
+    it('should respond to GET for base route', async () => {
+      const result = uut.root(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.equal(result.status, 'control', 'Returns static string')
+    })
+  })
+
+  describe('#GetNetworkInfo', () => {
+    // const getNetworkInfo = controlRoute.testableComponents.getNetworkInfo
+
+    it('should throw 500 when network issues', async () => {
+      // Save the existing RPC URL.
+      const savedUrl = process.env.RPC_BASEURL
+
+      // Manipulate the URL to cause a 500 network error.
+      process.env.RPC_BASEURL = 'http://fakeurl/api/'
+
+      await uut.getNetworkInfo(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      // Restore the saved URL.
+      process.env.RPC_BASEURL = savedUrl
+
+      assert.isAbove(
+        res.statusCode,
+        499,
+        'HTTP status code 500 or greater expected.'
+      )
+      // assert.include(result.error, "ENOTFOUND", "Error message expected")
+    })
+    it('returns proper error when downstream service stalls', async () => {
+      // Mock the timeout error.
+      sandbox.stub(uut.axios, 'request').throws({ code: 'ECONNABORTED' })
+
+      const result = await uut.getNetworkInfo(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.isAbove(res.statusCode, 499, 'HTTP status code 503 expected.')
+      assert.include(
+        result.error,
+        'Could not communicate with full node',
+        'Error message expected'
+      )
+    })
+
+    it('returns proper error when downstream service is down', async () => {
+      // Mock the timeout error.
+      sandbox.stub(uut.axios, 'request').throws({ code: 'ECONNREFUSED' })
+
+      const result = await uut.getNetworkInfo(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.isAbove(res.statusCode, 499, 'HTTP status code 503 expected.')
+      assert.include(
+        result.error,
+        'Could not communicate with full node',
+        'Error message expected'
+      )
+    })
+
+    it('should get info on the full node', async () => {
+      // Mock the RPC call for unit tests.
+      if (process.env.TEST === 'unit') {
+        sandbox
+          .stub(uut.axios, 'request')
+          .resolves({ data: { result: mockData.mockGetNetworkInfo } })
+      }
+
+      const result = await uut.getNetworkInfo(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.hasAnyKeys(result, [
+        'version',
+        'subversion',
+        'protocolversion',
+        'localservices',
+        'localrelay',
+        'timeoffset',
+        'networkactive',
+        'connections',
+        'networks',
+        'relayfee',
+        'excessutxocharge',
+        'localaddresses',
+        'warnings'
+      ])
+    })
+  })
+})

test/v4/e2e/address.js

@@ -0,0 +1,60 @@
+/*
+  End-to-end tests for the Address endpoint.
+  These tests assume that the repo is running locally and pointed at TESTNET
+*/
+
+'use strict'
+
+const rp = require('request-promise')
+
+// const rawtransactions = require('../../../dist/routes/v2/address')
+
+/*
+  This unconfirmed utxo test needs to be expanded in the future to automatically
+  create a transaction. For now, that is done manually and the address provided
+  as a constant.
+
+  1. Start rest running locally, pointed at TESTNET.
+  2. Fund each address with a small amount of tBCH
+  3. Run this program with `node address.js`
+  4. If successful, it will return the unconfirmed UTXOs.
+*/
+const addr1 = 'bchtest:qpdcp5pv7qphu5tsjfgwezld9n9aq9ue6swgqpf45c'
+const addr2 = 'bchtest:qzpvx999fagau0xqmvu3xvll9evapge7u5hcgeknzv'
+
+async function testSingleUnconfirmed () {
+  try {
+    const options = {
+      method: 'GET',
+      uri: `http://localhost:3000/v2/address/unconfirmed/${addr1}`,
+      resolveWithFullResponse: true,
+      json: true
+    }
+
+    await rp(options)
+    // console.log(`result.body: ${JSON.stringify(result.body, null, 2)}`)
+  } catch (err) {
+    // console.log(`Error: `, err)
+  }
+}
+testSingleUnconfirmed()
+
+async function testDoubleUnconfirmed () {
+  try {
+    const options = {
+      method: 'POST',
+      uri: 'http://localhost:3000/v2/address/unconfirmed',
+      resolveWithFullResponse: true,
+      json: true,
+      body: {
+        addresses: [addr1, addr2]
+      }
+    }
+
+    await rp(options)
+    // console.log(`result.body: ${JSON.stringify(result.body, null, 2)}`)
+  } catch (err) {
+    // console.log(`Error: `, err)
+  }
+}
+testDoubleUnconfirmed()

test/v4/encryption.js

@@ -0,0 +1,146 @@
+/*
+  TESTS FOR THE ENCRYPTION.JS LIBRARY
+
+  This test file uses the environment variable TEST to switch between unit
+  and integration tests. By default, TEST is set to 'unit'. Set this variable
+  to 'integration' to run the tests against BCH mainnet.
+
+  To-Do:
+*/
+
+'use strict'
+
+const chai = require('chai')
+const assert = chai.assert
+
+const sinon = require('sinon')
+
+// Set default environment variables for unit tests.
+if (!process.env.TEST) process.env.TEST = 'unit'
+
+// Only load blockbook library after setting BLOCKBOOK_URL env var.
+const EncryptionRoute = require('../../src/routes/v4/encryption')
+const encryptionRoute = new EncryptionRoute()
+
+// Mocking data.
+const { mockReq, mockRes } = require('./mocks/express-mocks')
+const mockData = require('./mocks/encryption-mocks')
+
+// Used for debugging.
+const util = require('util')
+util.inspect.defaultOptions = { depth: 1 }
+
+describe('#Encryption Router', () => {
+  let req, res
+  let sandbox
+  before(() => {
+    // console.log(`Testing type is: ${process.env.TEST}`)
+
+    if (!process.env.NETWORK) process.env.NETWORK = 'testnet'
+  })
+
+  // Setup the mocks before each test.
+  beforeEach(() => {
+    // Mock the req and res objects used by Express routes.
+    req = mockReq
+    res = mockRes
+
+    // Explicitly reset the parmas and body.
+    req.params = {}
+    req.body = {}
+    req.query = {}
+
+    sandbox = sinon.createSandbox()
+  })
+
+  afterEach(() => {
+    sandbox.restore()
+  })
+
+  after(() => {})
+
+  describe('#root', () => {
+    // root route handler.
+    const root = encryptionRoute.root
+
+    it('should respond to GET for base route', async () => {
+      const result = root(req, res)
+
+      assert.equal(result.status, 'encryption', 'Returns static string')
+    })
+  })
+
+  describe('#getPublicKey', () => {
+    it('should get public key from blockchain', async () => {
+      req.params.address =
+        'bitcoincash:qrehqueqhw629p6e57994436w730t4rzasnly00ht0'
+
+      // Mock the Insight URL for unit tests.
+      if (process.env.TEST === 'unit') {
+        sandbox
+          .stub(encryptionRoute.bchjs.Electrumx, 'transactions')
+          .resolves(mockData.mockFulcrumTxHistory)
+        sandbox
+          .stub(encryptionRoute.bchjs.RawTransactions, 'getRawTransaction')
+          .resolves(mockData.mockTxDetails2)
+      }
+
+      const result = await encryptionRoute.getPublicKey(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.property(result, 'success')
+      assert.equal(result.success, true)
+
+      assert.property(result, 'publicKey')
+      assert.equal(
+        result.publicKey,
+        '044eb40b025df18409f2a5197b010dd62a9e65d9a74e415e5b10367721a9c4baa7ebfee22d14b8ece1c9bd70c0d9e5e8b00b61b81b88a1b5ce6f24eac6b8a34b2c'
+      )
+    })
+
+    it('should return false for address with no tx history', async () => {
+      req.params.address =
+        'bitcoincash:qqwfpk04ecf69wuprj9yjys9rla5mk7rj5j8uthqel'
+
+      // Mock the Insight URL for unit tests.
+      if (process.env.TEST === 'unit') {
+        sandbox
+          .stub(encryptionRoute.bchjs.Electrumx, 'transactions')
+          .resolves(mockData.mockFulcrumNoTxHistory)
+      }
+
+      const result = await encryptionRoute.getPublicKey(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'No transaction history')
+    })
+
+    it('should return false for address with no send history', async () => {
+      req.params.address =
+        'bitcoincash:qq78nwj5x97yh6wtlfd27dtlwjuh70vkjc59h8tgtg'
+
+      // Mock the Insight URL for unit tests.
+      if (process.env.TEST === 'unit') {
+        sandbox
+          .stub(encryptionRoute.bchjs.Electrumx, 'transactions')
+          .resolves(mockData.mockFulcrumNoSendBalance)
+        sandbox
+          .stub(encryptionRoute.bchjs.RawTransactions, 'getRawTransaction')
+          .resolves(mockData.mockNoSendTx)
+      }
+
+      const result = await encryptionRoute.getPublicKey(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+
+      assert.property(result, 'publicKey')
+      assert.include(result.publicKey, 'not found')
+    })
+  })
+})

test/v4/helpers/panda.js

@@ -0,0 +1,29 @@
+'use strict'
+
+/**
+ * Read more about panda here: https://panda-suite.github.io/
+ */
+const panda = require('pandacash-core')
+
+const runLocalNode = done => {
+  const server = panda.server({
+    // always the same mnemonic
+    // mnemonic: "cigar magnet ocean purchase travel damp snack alone theme budget wagon wrong",
+    seedAccounts: true,
+    enableLogs: false,
+    debug: false
+  })
+
+  server.listen({
+    port: 48332,
+    walletPort: 48333
+  }, (err, pandaCashCore) => {
+    if (err) return console.error(err)
+
+    done()
+  })
+}
+
+module.exports = {
+  runLocalNode
+}

test/v4/integration/README.md

@@ -0,0 +1,7 @@
+This directory contains integration tests. To run them requires that
+a local copy of rest.bitcoin.com is running. The tests in this directory are
+exactly the same calls that end users would use for their app to interact
+directly with rest.bitcoin.com.
+
+At present, this directory focuses on raw-transations. But more integration tests
+will be added.

test/v4/integration/price.js

@@ -0,0 +1,45 @@
+/*
+  Integration tests for the price library.
+ */
+
+'use strict'
+
+const assert = require('chai').assert
+// const axios = require('axios')
+
+// Used for debugging.
+const util = require('util')
+util.inspect.defaultOptions = { depth: 1 }
+
+const Price = require('../../../src/routes/v4/price')
+const price = new Price()
+
+const { mockReq, mockRes } = require('../mocks/express-mocks')
+
+describe('#price', () => {
+  let req, res
+
+  beforeEach(() => {
+    // Mock the req and res objects used by Express routes.
+    req = mockReq
+    res = mockRes
+  })
+
+  describe('#getUSD', () => {
+    it('should get the USD price', async () => {
+      const result = await price.getUSD(req, res)
+      console.log(`result: ${util.inspect(result)}`)
+
+      assert.isNumber(result.usd)
+    })
+  })
+
+  describe('#getBCHAUSD', () => {
+    it('should get the USD price of BCHA', async () => {
+      const result = await price.getBCHAUSD(req, res)
+      console.log(`result: ${util.inspect(result)}`)
+
+      assert.isNumber(result.usd)
+    })
+  })
+})

test/v4/integration/rate-limits.js

@@ -0,0 +1,164 @@
+/*
+  These tests have been deprecated. To test bch-api rate limits, run the e2e
+  tests in the bch-js repository.
+ */
+
+'use strict'
+
+const chai = require('chai')
+const assert = chai.assert
+const axios = require('axios')
+
+// Used for debugging.
+const util = require('util')
+util.inspect.defaultOptions = { depth: 1 }
+
+// const SERVER = `http://192.168.0.36:12400/v4/`
+const SERVER = 'http://localhost:3000/v4/'
+// const SERVER = 'https://api.fullstack.cash/v4/'
+//
+// const TEST_JWT =
+//   'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjVlODhhY2JmMDIyMWMxMDAxMmFkOTNmZiIsImVtYWlsIjoiY2hyaXMudHJvdXRuZXJAZ21haWwuY29tIiwiYXBpTGV2ZWwiOjQwLCJyYXRlTGltaXQiOjMsImlhdCI6MTYwMDYyODk1MSwiZXhwIjoxNjAzMjIwOTUxfQ.JPXDJQsxJFtCGZjHOd-hRfJuY41Ef_FQ4ET06CtYdNk'
+
+describe('#JWT rate limits', () => {
+  it('should get control/getNetworkInfo() with no auth', async () => {
+    const options = {
+      method: 'GET',
+      url: `${SERVER}control/getNetworkInfo`
+    }
+
+    const result = await axios(options)
+    // console.log(`result.status: ${result.status}`)
+    // console.log(`result.data: ${util.inspect(result.data)}`)
+
+    assert.equal(result.status, 200)
+    assert.hasAnyKeys(result.data, ['version'])
+  })
+
+  it('should trigger rate-limit handler if rate limits exceeds 20 request per minute', async () => {
+    try {
+      const options = {
+        method: 'GET',
+        url: `${SERVER}control/getNetworkInfo`
+      }
+
+      const promises = []
+      for (let i = 0; i < 30; i++) {
+        const promise = axios(options)
+        promises.push(promise)
+      }
+
+      await Promise.all(promises)
+
+      assert.fail('Unexpected result!')
+    } catch (err) {
+      console.log('err: ', err)
+
+      assert.equal(err.response.status, 429)
+      assert.include(err.response.data.error, 'Too many requests')
+    }
+  })
+
+  // it('should not trigger rate-limit handler if correct pro-tier password is used', async () => {
+  //   try {
+  //     const username = 'BITBOX'
+  //
+  //     // Pro-tier is accessed by using the right password.
+  //     const password = 'BITBOX'
+  //     // const password = "something"
+  //
+  //     const combined = `${username}:${password}`
+  //     const base64Credential = Buffer.from(combined).toString('base64')
+  //     const readyCredential = `Basic ${base64Credential}`
+  //
+  //     const options = {
+  //       method: 'GET',
+  //       url: `${SERVER}control/getNetworkInfo`,
+  //       headers: { Authorization: readyCredential }
+  //     }
+  //
+  //     const promises = []
+  //     for (let i = 0; i < 30; i++) {
+  //       const promise = axios(options)
+  //       promises.push(promise)
+  //     }
+  //
+  //     await Promise.all(promises)
+  //
+  //     assert.equal(true, true, 'Not throwing an error is a pass!')
+  //   } catch (err) {
+  //     // console.log(`err.response: ${util.inspect(err.response)}`)
+  //
+  //     assert.equal(
+  //       true,
+  //       false,
+  //       'This error handler should not have been triggered. Is the password correct?'
+  //     )
+  //   }
+  // })
+
+  // it('should trigger rate-limit handler if rate limits exceeds pro-tier limit', async () => {
+  //   try {
+  //     const username = 'BITBOX'
+  //
+  //     // Pro-tier is accessed by using the right password.
+  //     const password = 'BITBOX'
+  //     // const password = "something"
+  //
+  //     const combined = `${username}:${password}`
+  //     const base64Credential = Buffer.from(combined).toString('base64')
+  //     const readyCredential = `Basic ${base64Credential}`
+  //
+  //     // Actual rate limit is 60 per minute X 4 nodes = 240 rpm.
+  //     const options = {
+  //       method: 'GET',
+  //       url: `${SERVER}control/getNetworkInfo`,
+  //       headers: { Authorization: readyCredential }
+  //     }
+  //
+  //     const promises = []
+  //     for (let i = 0; i < 80; i++) {
+  //       const promise = axios(options)
+  //       promises.push(promise)
+  //     }
+  //
+  //     await Promise.all(promises)
+  //
+  //     assert.equal(true, false, 'Unexpected result!')
+  //   } catch (err) {
+  //     // console.log(`err.response: ${util.inspect(err.response)}`)
+  //
+  //     assert.equal(err.response.status, 429)
+  //     assert.include(err.response.data.error, 'Too many requests')
+  //   }
+  // })
+
+  // it('should unlock pro-tier for a valid JWT token', async () => {
+  //   try {
+  //     // Actual rate limit is 60 per minute X 4 nodes = 240 rpm.
+  //     const options = {
+  //       method: 'GET',
+  //       url: `${SERVER}control/`,
+  //       headers: {
+  //         Authorization: `Token ${TEST_JWT}`
+  //       }
+  //     }
+  //
+  //     const promises = []
+  //     for (let i = 0; i < 60; i++) {
+  //       const promise = axios(options)
+  //       promises.push(promise)
+  //     }
+  //
+  //     await Promise.all(promises)
+  //
+  //     // assert.equal(true, false, "Unexpected result!")
+  //     assert.equal(true, true, 'Not throwing an error is a pass!')
+  //   } catch (err) {
+  //     console.log(`err.response: ${util.inspect(err.response)}`)
+  //
+  //     assert.equal(true, false, 'Unexpected result!')
+  //   }
+  //   // Override default timeout for this test.
+  // }).timeout(20000)
+})

test/v4/integration/raw-transactions.js

@@ -0,0 +1,191 @@
+/*
+  These integration tests are intended to be run against a live local copy of
+  rest.bitcoin.com. They exercise the endpoints in the same way the SDK or
+  end-user application would. These tests were created to replace the parts
+  removed from the swagger UI, that otherwise would have excersiced these endpoints.
+
+  TODO:
+  -/rawtransactions/sendRawTransaction is more appropropriate for an e2e test,
+  so it is omitted here.
+*/
+
+'use strict'
+
+const chai = require('chai')
+const assert = chai.assert
+// const rawtransactions = require('../../../dist/routes/v2/rawtransactions')
+const rp = require('request-promise')
+
+// Used for debugging.
+const util = require('util')
+util.inspect.defaultOptions = { depth: 1 }
+
+// const mockData = require('../mocks/raw-transactions-mocks')
+
+describe('#Raw-Transactions', () => {
+  describe('#root', () => {
+    it('should return root', async () => {
+      const options = {
+        method: 'GET',
+        uri: 'http://localhost:3000/v2/rawtransactions/',
+        resolveWithFullResponse: true,
+        json: true
+      }
+
+      const result = await rp(options)
+      // console.log(`result: ${JSON.stringify(result, null, 0)}`)
+
+      assert.equal(result.body.status, 'rawtransactions')
+    })
+  })
+
+  describe('#whCreateTx', () => {
+    it('should return tx hex', async () => {
+      const minIn = {
+        txid:
+          'f7ed9cf23dee85910f6269c9a101a75fcfd2f3c6fc81f17fad824ff7aaf99ab2',
+        vout: 1
+      }
+
+      const options = {
+        method: 'PUT',
+        uri: 'http://localhost:3000/v2/rawtransactions/create',
+        resolveWithFullResponse: true,
+        json: true,
+        body: {
+          // inputs: [mockData.mockWHCreateInput],
+          inputs: [minIn],
+          outputs: {}
+        }
+      }
+
+      const result = await rp(options)
+      // console.log(`result.body: ${JSON.stringify(result.body, null, 0)}`)
+
+      assert.equal(
+        result.body,
+        '0200000001b29af9aaf74f82ad7ff181fcc6f3d2cf5fa701a1c969620f9185ee3df29cedf70100000000ffffffff0000000000'
+      )
+    })
+  })
+
+  describe('#whOpReturn', () => {
+    it('should return tx hex', async () => {
+      const options = {
+        method: 'PUT',
+        uri: 'http://localhost:3000/v2/rawtransactions/opreturn',
+        resolveWithFullResponse: true,
+        json: true,
+        body: {
+          rawtx: '01000000000000000000',
+          payload: '00000000000000020000000006dac2c0'
+        }
+      }
+
+      const result = await rp(options)
+      // console.log(`result.body: ${JSON.stringify(result.body, null, 0)}`)
+
+      assert.equal(
+        result.body,
+        '0100000000010000000000000000166a140877686300000000000000020000000006dac2c000000000'
+      )
+    })
+  })
+
+  describe('#whReference', () => {
+    it('should return tx hex', async () => {
+      const options = {
+        method: 'PUT',
+        uri: 'http://localhost:3000/v2/rawtransactions/reference',
+        resolveWithFullResponse: true,
+        json: true,
+        body: {
+          rawtx:
+            '0100000001a7a9402ecd77f3c9f745793c9ec805bfa2e14b89877581c734c774864247e6f50400000000ffffffff03aa0a0000000000001976a9146d18edfe073d53f84dd491dae1379f8fb0dfe5d488ac5c0d0000000000004751210252ce4bdd3ce38b4ebbc5a6e1343608230da508ff12d23d85b58c964204c4cef3210294cc195fc096f87d0f813a337ae7e5f961b1c8a18f1f8604a909b3a5121f065b52aeaa0a0000000000001976a914946cb2e08075bcbaf157e47bcb67eb2b2339d24288ac00000000',
+          destination: 'bitcoincash:qrn60nerx5zug4u4hal06atep3lzhtecvy4pxk75lf',
+          amount: 0.005
+        }
+      }
+
+      const result = await rp(options)
+      // console.log(`result.body: ${JSON.stringify(result.body, null, 0)}`)
+
+      assert.isString(result.body)
+    })
+  })
+
+  describe('#whChangeOutput', () => {
+    it('should return tx hex', async () => {
+      const options = {
+        method: 'PUT',
+        uri: 'http://localhost:3000/v2/rawtransactions/change',
+        resolveWithFullResponse: true,
+        json: true,
+        body: {
+          rawtx:
+            '0100000001b15ee60431ef57ec682790dec5a3c0d83a0c360633ea8308fbf6d5fc10a779670400000000ffffffff025c0d00000000000047512102f3e471222bb57a7d416c82bf81c627bfcd2bdc47f36e763ae69935bba4601ece21021580b888ff56feb27f17f08802ebed26258c23697d6a462d43fc13b565fda2dd52aeaa0a0000000000001976a914946cb2e08075bcbaf157e47bcb67eb2b2339d24288ac00000000',
+          destination: 'bitcoincash:qrn60nerx5zug4u4hal06atep3lzhtecvy4pxk75lf',
+          prevtxs: [
+            {
+              txid:
+                '6779a710fcd5f6fb0883ea3306360c3ad8c0a3c5de902768ec57ef3104e65eb1',
+              vout: 4,
+              scriptPubKey:
+                '76a9147b25205fd98d462880a3e5b0541235831ae959e588ac',
+              value: 0.00068257
+            }
+          ],
+          fee: 0.000035
+        }
+      }
+
+      const result = await rp(options)
+      // console.log(`result.body: ${JSON.stringify(result.body, null, 0)}`)
+
+      assert.isString(result.body)
+    })
+  })
+
+  describe('#whInput', () => {
+    it('should return tx hex', async () => {
+      const options = {
+        method: 'PUT',
+        uri: 'http://localhost:3000/v2/rawtransactions/input',
+        resolveWithFullResponse: true,
+        json: true,
+        body: {
+          txid:
+            'b006729017df05eda586df9ad3f8ccfee5be340aadf88155b784d1fc0e8342ee',
+          n: 0
+        }
+      }
+
+      const result = await rp(options)
+      // console.log(`result.body: ${JSON.stringify(result.body, null, 0)}`)
+
+      assert.isString(result.body)
+    })
+  })
+
+  describe('#getRawTransaction', () => {
+    it('should return tx hex', async () => {
+      const options = {
+        method: 'POST',
+        uri: 'http://localhost:3000/v2/rawtransactions/getRawTransaction',
+        resolveWithFullResponse: true,
+        json: true,
+        body: {
+          txids: [
+            '0e3e2357e806b6cdb1f70b54c3a3a17b6714ee1f0e68bebb44a74b1efd512098'
+          ],
+          verbose: true
+        }
+      }
+
+      const result = await rp(options)
+      // console.log(`result.body: ${util.inspect(result.body)}`)
+
+      assert.isArray(result.body)
+    })
+  })
+})

test/v4/integration/slp.js

@@ -0,0 +1,419 @@
+/*
+  These integration tests need to be run against a live SLPDB. They query
+  against a live SLPDB and test the results against known token stats.
+ */
+
+'use strict'
+
+const assert = require('chai').assert
+// const axios = require('axios')
+
+// Used for debugging.
+const util = require('util')
+util.inspect.defaultOptions = { depth: 1 }
+
+// Exit if SLPDB URL is not defined.
+if (!process.env.SLPDB_URL) {
+  throw new Error(
+    'SLPDB_URL and SLPDB_PASS must be defined in order to run these tests.'
+  )
+}
+
+const SLP = require('../../../src/routes/v4/slp')
+const slp = new SLP()
+
+const BCHJS = require('@psf/bch-js')
+const bchjs = new BCHJS()
+
+const { mockReq, mockRes } = require('../mocks/express-mocks')
+
+describe('#slp', () => {
+  let req, res
+
+  beforeEach(() => {
+    // Mock the req and res objects used by Express routes.
+    req = mockReq
+    res = mockRes
+  })
+
+  describe('#tokenStats', () => {
+    it('should get token stats for token with no mint baton', async () => {
+      req.params.tokenId =
+        '497291b8a1dfe69c8daea50677a3d31a5ef0e9484d8bebb610dac64bbc202fb7'
+      // 'a4fb5c2da1aa064e25018a43f9165040071d9e984ba190c222a7f59053af84b2'
+
+      const result = await slp.tokenStats(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      // Assert that expected properties exist.
+      assert.property(result, 'decimals')
+      assert.property(result, 'timestamp')
+      assert.property(result, 'versionType')
+      assert.property(result, 'documentUri')
+      assert.property(result, 'symbol')
+      assert.property(result, 'name')
+      assert.property(result, 'containsBaton')
+      assert.property(result, 'id')
+      assert.property(result, 'documentHash')
+      assert.property(result, 'initialTokenQty')
+      assert.property(result, 'blockCreated')
+      assert.property(result, 'blockLastActiveSend')
+      assert.property(result, 'blockLastActiveMint')
+      assert.property(result, 'txnsSinceGenesis')
+      assert.property(result, 'validAddresses')
+      assert.property(result, 'mintingBatonStatus')
+      assert.property(result, 'timestampUnix')
+      assert.property(result, 'totalMinted')
+      assert.property(result, 'totalBurned')
+      assert.property(result, 'circulatingSupply')
+
+      // baton was never created.
+      assert.equal(result.containsBaton, false)
+    })
+
+    it('should get token stats for token with a mint baton', async () => {
+      req.params.tokenId =
+        'a4fb5c2da1aa064e25018a43f9165040071d9e984ba190c222a7f59053af84b2'
+
+      const result = await slp.tokenStats(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      // Assert that expected properties exist.
+      assert.property(result, 'decimals')
+      assert.property(result, 'timestamp')
+      assert.property(result, 'versionType')
+      assert.property(result, 'documentUri')
+      assert.property(result, 'symbol')
+      assert.property(result, 'name')
+      assert.property(result, 'containsBaton')
+      assert.property(result, 'id')
+      assert.property(result, 'documentHash')
+      assert.property(result, 'initialTokenQty')
+      assert.property(result, 'blockCreated')
+      assert.property(result, 'blockLastActiveSend')
+      assert.property(result, 'blockLastActiveMint')
+      assert.property(result, 'txnsSinceGenesis')
+      assert.property(result, 'validAddresses')
+      assert.property(result, 'mintingBatonStatus')
+      assert.property(result, 'timestampUnix')
+      assert.property(result, 'totalMinted')
+      assert.property(result, 'totalBurned')
+      assert.property(result, 'circulatingSupply')
+
+      // baton was created.
+      assert.equal(result.containsBaton, true)
+    })
+  })
+
+  describe('#generateSendOpReturn', () => {
+    it('should return OP_RETURN script', async () => {
+      req.body.tokenUtxos = [
+        {
+          tokenId:
+            '0a321bff9761f28e06a268b14711274bb77617410a16807bd0437ef234a072b1',
+          decimals: 0,
+          tokenQty: 2
+        }
+      ]
+      req.body.sendQty = 1.5
+
+      const result = await slp.generateSendOpReturn(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.hasAllKeys(result, ['script', 'outputs'])
+      assert.isNumber(result.outputs)
+    })
+  })
+
+  describe('#hydrateUtxos', () => {
+    it('should return utxo details', async () => {
+      const utxos = [
+        {
+          utxos: [
+            {
+              txid:
+                'd56a2b446d8149c39ca7e06163fe8097168c3604915f631bc58777d669135a56',
+              vout: 3,
+              value: '6816',
+              height: 606848,
+              confirmations: 13,
+              satoshis: 6816
+            },
+            {
+              txid:
+                'd56a2b446d8149c39ca7e06163fe8097168c3604915f631bc58777d669135a56',
+              vout: 2,
+              value: '546',
+              height: 606848,
+              confirmations: 13,
+              satoshis: 546
+            }
+          ]
+        }
+      ]
+
+      req.body.utxos = utxos
+      const result = await slp.hydrateUtxos(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      // Test the general structure of the output.
+      assert.isArray(result.slpUtxos)
+      assert.equal(result.slpUtxos.length, 1)
+      assert.equal(result.slpUtxos[0].utxos.length, 2)
+
+      // Test the non-slp UTXO.
+      assert.property(result.slpUtxos[0].utxos[0], 'txid')
+      assert.property(result.slpUtxos[0].utxos[0], 'vout')
+      assert.property(result.slpUtxos[0].utxos[0], 'value')
+      assert.property(result.slpUtxos[0].utxos[0], 'height')
+      assert.property(result.slpUtxos[0].utxos[0], 'confirmations')
+      assert.property(result.slpUtxos[0].utxos[0], 'satoshis')
+      assert.property(result.slpUtxos[0].utxos[0], 'isValid')
+      assert.equal(result.slpUtxos[0].utxos[0].isValid, false)
+
+      // Test the slp UTXO.
+      assert.property(result.slpUtxos[0].utxos[1], 'txid')
+      assert.property(result.slpUtxos[0].utxos[1], 'vout')
+      assert.property(result.slpUtxos[0].utxos[1], 'value')
+      assert.property(result.slpUtxos[0].utxos[1], 'height')
+      assert.property(result.slpUtxos[0].utxos[1], 'confirmations')
+      assert.property(result.slpUtxos[0].utxos[1], 'satoshis')
+      assert.property(result.slpUtxos[0].utxos[1], 'isValid')
+      assert.equal(result.slpUtxos[0].utxos[1].isValid, true)
+      assert.property(result.slpUtxos[0].utxos[1], 'transactionType')
+      assert.property(result.slpUtxos[0].utxos[1], 'tokenId')
+      assert.property(result.slpUtxos[0].utxos[1], 'tokenTicker')
+      assert.property(result.slpUtxos[0].utxos[1], 'tokenName')
+      assert.property(result.slpUtxos[0].utxos[1], 'tokenDocumentUrl')
+      assert.property(result.slpUtxos[0].utxos[1], 'tokenDocumentHash')
+      assert.property(result.slpUtxos[0].utxos[1], 'decimals')
+      assert.property(result.slpUtxos[0].utxos[1], 'tokenType')
+      assert.property(result.slpUtxos[0].utxos[1], 'tokenQty')
+    })
+
+    it('should process data directly from Electrumx', async () => {
+      const addrs = [
+        'bitcoincash:qq6mvsm7l92d77zpymmltvaw09p5uzghyuyx7spygg',
+        'bitcoincash:qpjdrs8qruzh8xvusdfmutjx62awcepnhyperm3g89',
+        'bitcoincash:qzygn28zpgeemnptkn26xzyuzzfu9l8f9vfvq7kptk'
+      ]
+
+      const utxos = await bchjs.Electrumx.utxo(addrs)
+      // console.log(`utxos: ${JSON.stringify(utxos, null, 2)}`)
+
+      req.body.utxos = utxos.utxos
+      const result = await slp.hydrateUtxos(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      // Test the general structure of the output.
+      assert.isArray(result.slpUtxos)
+      assert.equal(result.slpUtxos.length, 3)
+      assert.equal(result.slpUtxos[0].utxos.length, 1)
+      assert.equal(result.slpUtxos[1].utxos.length, 1)
+      assert.equal(result.slpUtxos[2].utxos.length, 2)
+    })
+  })
+
+  describe('#validate2Single', () => {
+    it('should invalidate a known invalid TXID', async () => {
+      const txid =
+        'f7e5199ef6669ad4d078093b3ad56e355b6ab84567e59ad0f08a5ad0244f783a'
+
+      req.params.txid = txid
+      const result = await slp.validate2Single(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.equal(result.txid, txid)
+      assert.equal(result.isValid, false)
+    })
+
+    it('should validate a known valid TXID', async () => {
+      const txid =
+        '3a4b628cbcc183ab376d44ce5252325f042268307ffa4a53443e92b6d24fb488'
+
+      req.params.txid = txid
+      const result = await slp.validate2Single(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.equal(result.txid, txid)
+      assert.equal(result.isValid, true)
+    })
+
+    // CT 10-11-2020: This test is valid, but because of the cacheing built
+    // into slp-validate, it will not consistently pass or fail. To manually
+    // Run this test, re-start slp-api or find a token txid with a long DAG.
+    // it('should cancel if validation takes too long', async () => {
+    //   const txid =
+    //     'eacb1085dfa296fef6d4ae2c0f4529a1bef096dd2325bdcc6dcb5241b3bdb579'
+    //
+    //   req.params.txid = txid
+    //   const result = await slp.validate2Single(req, res)
+    //   // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+    //
+    //   assert.isAbove(res.statusCode, 499, 'HTTP status code 503 expected.')
+    //   assert.include(
+    //     result.error,
+    //     'Could not communicate with full node',
+    //     'Error message expected'
+    //   )
+    // })
+  })
+
+  describe('#validateBulk', () => {
+    it('should handle a mix of valid, invalid, and non-SLP txs', async () => {
+      const txids = [
+        // Malformed SLP tx
+        'f7e5199ef6669ad4d078093b3ad56e355b6ab84567e59ad0f08a5ad0244f783a',
+        // Normal TX (non-SLP)
+        '01cdaec2f8b311fc2d6ecc930247bd45fa696dc204ab684596e281fe1b06c1f0',
+        // Valid PSF SLP tx
+        'daf4d8b8045e7a90b7af81bfe2370178f687da0e545511bce1c9ae539eba5ffd',
+        // Valid SLP token not in whitelist
+        '3a4b628cbcc183ab376d44ce5252325f042268307ffa4a53443e92b6d24fb488',
+        // Token send on BCHN network.
+        '402c663379d9699b6e2dd38737061e5888c5a49fca77c97ab98e79e08959e019',
+        // Token send on ABC network.
+        '336bfe2168aac4c3303508a9e8548a0d33797a83b85b76a12d845c8d6674f79d',
+        // Known invalid SLP token send of PSF tokens.
+        '2bf691ad3679d928fef880b8a45b93b233f8fa0d0a92cf792313dbe77b1deb74'
+      ]
+
+      req.body.txids = txids
+      const result = await slp.validateBulk(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      // BCHN expected results
+      if (process.env.ISBCHN) {
+        assert.equal(result[0].txid, txids[0])
+        assert.equal(result[0].valid, null)
+
+        assert.equal(result[1].txid, txids[1])
+        assert.equal(result[1].valid, null)
+
+        assert.equal(result[2].txid, txids[2])
+        assert.equal(result[2].valid, true)
+
+        assert.equal(result[3].txid, txids[3])
+        assert.equal(result[3].valid, true)
+
+        // Note: This should change from null to true once SLPDB finishes indexing.
+        assert.equal(result[4].txid, txids[4])
+        assert.equal(result[4].valid, null)
+
+        assert.equal(result[5].txid, txids[5])
+        assert.equal(result[5].valid, null)
+
+        assert.equal(result[6].txid, txids[6])
+        assert.equal(result[6].valid, false)
+        assert.include(
+          result[6].invalidReason,
+          'Token outputs are greater than valid token inputs'
+        )
+      } else {
+        assert.equal(result[0].txid, txids[0])
+        assert.equal(result[0].valid, null)
+
+        assert.equal(result[1].txid, txids[1])
+        assert.equal(result[1].valid, null)
+
+        assert.equal(result[2].txid, txids[2])
+        assert.equal(result[2].valid, true)
+
+        assert.equal(result[3].txid, txids[3])
+        assert.equal(result[3].valid, true)
+
+        assert.equal(result[4].txid, txids[4])
+        assert.equal(result[4].valid, null)
+
+        assert.equal(result[5].txid, txids[5])
+        assert.equal(result[5].valid, true)
+
+        assert.equal(result[6].txid, txids[6])
+        assert.equal(result[6].valid, false)
+        assert.include(
+          result[6].invalidReason,
+          'Token outputs are greater than valid token inputs'
+        )
+      }
+    })
+  })
+
+  describe('#validate3Bulk', () => {
+    it('should handle a mix of valid, invalid, and non-SLP txs', async () => {
+      const txids = [
+        // Malformed SLP tx
+        'f7e5199ef6669ad4d078093b3ad56e355b6ab84567e59ad0f08a5ad0244f783a',
+        // Normal TX (non-SLP)
+        '01cdaec2f8b311fc2d6ecc930247bd45fa696dc204ab684596e281fe1b06c1f0',
+        // Valid PSF SLP tx
+        'daf4d8b8045e7a90b7af81bfe2370178f687da0e545511bce1c9ae539eba5ffd',
+        // Valid SLP token not in whitelist
+        '3a4b628cbcc183ab376d44ce5252325f042268307ffa4a53443e92b6d24fb488',
+        // Token send on BCHN network.
+        '402c663379d9699b6e2dd38737061e5888c5a49fca77c97ab98e79e08959e019',
+        // Token send on ABC network.
+        '336bfe2168aac4c3303508a9e8548a0d33797a83b85b76a12d845c8d6674f79d',
+        // Known invalid SLP token send of PSF tokens.
+        '2bf691ad3679d928fef880b8a45b93b233f8fa0d0a92cf792313dbe77b1deb74'
+      ]
+
+      req.body.txids = txids
+      const result = await slp.validate3Bulk(req, res)
+      console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      // BCHN expected results
+      if (process.env.ISBCHN) {
+        assert.equal(result[0].txid, txids[0])
+        assert.equal(result[0].valid, null)
+
+        assert.equal(result[1].txid, txids[1])
+        assert.equal(result[1].valid, null)
+
+        assert.equal(result[2].txid, txids[2])
+        assert.equal(result[2].valid, true)
+
+        assert.equal(result[3].txid, txids[3])
+        assert.equal(result[3].valid, null)
+
+        // Note: This should change from null to true once SLPDB finishes indexing.
+        assert.equal(result[4].txid, txids[4])
+        assert.equal(result[4].valid, null)
+
+        assert.equal(result[5].txid, txids[5])
+        assert.equal(result[5].valid, null)
+
+        assert.equal(result[6].txid, txids[6])
+        assert.equal(result[6].valid, false)
+        assert.include(
+          result[6].invalidReason,
+          'Token outputs are greater than valid token inputs'
+        )
+      } else {
+        assert.equal(result[0].txid, txids[0])
+        assert.equal(result[0].valid, null)
+
+        assert.equal(result[1].txid, txids[1])
+        assert.equal(result[1].valid, null)
+
+        assert.equal(result[2].txid, txids[2])
+        assert.equal(result[2].valid, true)
+
+        assert.equal(result[3].txid, txids[3])
+        assert.equal(result[3].valid, true)
+
+        assert.equal(result[4].txid, txids[4])
+        assert.equal(result[4].valid, null)
+
+        assert.equal(result[5].txid, txids[5])
+        assert.equal(result[5].valid, true)
+
+        assert.equal(result[6].txid, txids[6])
+        assert.equal(result[6].valid, false)
+        assert.include(
+          result[6].invalidReason,
+          'Token outputs are greater than valid token inputs'
+        )
+      }
+    })
+  })
+})

test/v4/integration/slpdb.js

@@ -0,0 +1,31 @@
+/*
+  These integration tests need to be run against a live SLPDB. They query
+  against a live SLPDB and test the results against known token stats.
+ */
+
+'use strict'
+
+// const chai = require('chai')
+// const assert = chai.assert
+// const axios = require('axios')
+
+// Used for debugging.
+const util = require('util')
+util.inspect.defaultOptions = { depth: 1 }
+
+// Exit if SLPDB URL is not defined.
+if (!process.env.SLPDB_URL) {
+  throw new Error('SLPDB_URL and SLPDB_PASS must be defined in order to run these tests.')
+}
+
+const SLPDB = require('../../../src/routes/v4/services/slpdb')
+const slpdb = new SLPDB()
+
+describe('#slpdb', () => {
+  describe('#getTotalCirculating', () => {
+    it('should get circulating supply', async () => {
+      const result = await slpdb.getTotalCirculating('b10677aef051b73e6b170c1c0824da33a3e0680ab5a01cd8d76aa77840fccfb4')
+      console.log('result: ', result)
+    })
+  })
+})

test/v4/mining.js

@@ -0,0 +1,224 @@
+/*
+  TESTS FOR THE MINING.TS LIBRARY
+
+  This test file uses the environment variable TEST to switch between unit
+  and integration tests. By default, TEST is set to 'unit'. Set this variable
+  to 'integration' to run the tests against BCH mainnet.
+*/
+
+'use strict'
+
+const chai = require('chai')
+const assert = chai.assert
+const MiningRoute = require('../../src/routes/v4/full-node/mining')
+const uut = new MiningRoute()
+
+// const nock = require('nock') // HTTP mocking
+const sinon = require('sinon')
+
+let originalEnvVars // Used during transition from integration to unit tests.
+
+// Mocking data.
+const { mockReq, mockRes } = require('./mocks/express-mocks')
+const mockData = require('./mocks/mining-mocks')
+
+// Used for debugging.
+const util = require('util')
+util.inspect.defaultOptions = { depth: 1 }
+
+describe('#Mining', () => {
+  let req, res
+  let sandbox
+  before(() => {
+    // Save existing environment variables.
+    originalEnvVars = {
+      BITCOINCOM_BASEURL: process.env.BITCOINCOM_BASEURL,
+      RPC_BASEURL: process.env.RPC_BASEURL,
+      RPC_USERNAME: process.env.RPC_USERNAME,
+      RPC_PASSWORD: process.env.RPC_PASSWORD
+    }
+
+    // Set default environment variables for unit tests.
+    if (!process.env.TEST) process.env.TEST = 'unit'
+    if (process.env.TEST === 'unit') {
+      process.env.BITCOINCOM_BASEURL = 'http://fakeurl/api/'
+      process.env.RPC_BASEURL = 'http://fakeurl/api'
+      process.env.RPC_USERNAME = 'fakeusername'
+      process.env.RPC_PASSWORD = 'fakepassword'
+    }
+  })
+
+  // Setup the mocks before each test.
+  beforeEach(() => {
+    // Mock the req and res objects used by Express routes.
+    req = mockReq
+    res = mockRes
+
+    // Explicitly reset the parmas and body.
+    req.params = {}
+    req.body = {}
+    req.query = {}
+
+    sandbox = sinon.createSandbox()
+  })
+
+  afterEach(() => {
+    // Restore Sandbox
+    sandbox.restore()
+  })
+
+  after(() => {
+    // Restore any pre-existing environment variables.
+    process.env.BITCOINCOM_BASEURL = originalEnvVars.BITCOINCOM_BASEURL
+    process.env.RPC_BASEURL = originalEnvVars.RPC_BASEURL
+    process.env.RPC_USERNAME = originalEnvVars.RPC_USERNAME
+    process.env.RPC_PASSWORD = originalEnvVars.RPC_PASSWORD
+  })
+
+  describe('#root', async () => {
+    // root route handler.
+    it('should respond to GET for base route', async () => {
+      const result = uut.root(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.equal(result.status, 'mining', 'Returns static string')
+    })
+  })
+
+  describe('#getMiningInfo', async () => {
+    it('should throw 503 when network issues', async () => {
+      // Save the existing RPC URL.
+      const savedUrl2 = process.env.RPC_BASEURL
+
+      // Manipulate the URL to cause a 500 network error.
+      process.env.RPC_BASEURL = 'http://fakeurl/api/'
+
+      await uut.getMiningInfo(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      // Restore the saved URL.
+      process.env.RPC_BASEURL = savedUrl2
+
+      assert.isAbove(
+        res.statusCode,
+        499,
+        'HTTP status code 500 or greater expected.'
+      )
+      // assert.include(result.error,"Network error: Could not communicate with full node","Error message expected")
+    })
+    it('returns proper error when downstream service stalls', async () => {
+      // Mock the timeout error.
+      sandbox.stub(uut.axios, 'request').throws({ code: 'ECONNABORTED' })
+
+      const result = await uut.getMiningInfo(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.isAbove(res.statusCode, 499, 'HTTP status code 503 expected.')
+      assert.include(
+        result.error,
+        'Could not communicate with full node',
+        'Error message expected'
+      )
+    })
+
+    it('returns proper error when downstream service is down', async () => {
+      // Mock the timeout error.
+      sandbox.stub(uut.axios, 'request').throws({ code: 'ECONNREFUSED' })
+
+      const result = await uut.getMiningInfo(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.isAbove(res.statusCode, 499, 'HTTP status code 503 expected.')
+      assert.include(
+        result.error,
+        'Could not communicate with full node',
+        'Error message expected'
+      )
+    })
+
+    it('should GET mining information', async () => {
+      // Mock the RPC call for unit tests.
+      if (process.env.TEST === 'unit') {
+        sandbox
+          .stub(uut.axios, 'request')
+          .resolves({ data: { result: mockData.mockMiningInfo } })
+      }
+
+      const result = await uut.getMiningInfo(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.property(result, 'blocks')
+      assert.property(result, 'difficulty')
+      assert.property(result, 'networkhashps')
+      assert.property(result, 'pooledtx')
+      assert.property(result, 'chain')
+      assert.property(result, 'warnings')
+    })
+  })
+
+  describe('#getNetworkHashPS', async () => {
+    it('should throw 503 when network issues', async () => {
+      // Save the existing RPC URL.
+      const savedUrl2 = process.env.RPC_BASEURL
+
+      // Manipulate the URL to cause a 500 network error.
+      process.env.RPC_BASEURL = 'http://fakeurl/api/'
+
+      await uut.getNetworkHashPS(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      // Restore the saved URL.
+      process.env.RPC_BASEURL = savedUrl2
+
+      assert.isAbove(
+        res.statusCode,
+        499,
+        'HTTP status code 500 or greater expected.'
+      )
+      // assert.include(result.error,"Network error: Could not communicate with full node","Error message expected")
+    })
+    it('returns proper error when downstream service stalls', async () => {
+      // Mock the timeout error.
+      sandbox.stub(uut.axios, 'request').throws({ code: 'ECONNABORTED' })
+
+      const result = await uut.getNetworkHashPS(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.isAbove(res.statusCode, 499, 'HTTP status code 503 expected.')
+      assert.include(
+        result.error,
+        'Could not communicate with full node',
+        'Error message expected'
+      )
+    })
+
+    it('returns proper error when downstream service is down', async () => {
+      // Mock the timeout error.
+      sandbox.stub(uut.axios, 'request').throws({ code: 'ECONNREFUSED' })
+
+      const result = await uut.getNetworkHashPS(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.isAbove(res.statusCode, 499, 'HTTP status code 503 expected.')
+      assert.include(
+        result.error,
+        'Could not communicate with full node',
+        'Error message expected'
+      )
+    })
+
+    it('should GET Network Hash per second', async () => {
+      // Mock the RPC call for unit tests.
+      if (process.env.TEST === 'unit') {
+        sandbox
+          .stub(uut.axios, 'request')
+          .resolves({ data: { result: 517604755.6648782 } })
+      }
+
+      const result = await uut.getNetworkHashPS(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.isNumber(result)
+    })
+  })
+})

test/v4/mocks/address-mock.js

@@ -0,0 +1,160 @@
+/*
+  This library contains mocking data for running unit tests on the address route.
+*/
+
+'use strict'
+
+const mockAddressDetails = {
+  addrStr: '1Fg4r9iDrEkCcDmHTy2T79EusNfhyQpu7W',
+  balance: 0.00126419,
+  balanceSat: 126419,
+  totalReceived: 0.02175868,
+  totalReceivedSat: 2175868,
+  totalSent: 0.02049449,
+  totalSentSat: 2049449,
+  unconfirmedBalance: 0,
+  unconfirmedBalanceSat: 0,
+  unconfirmedTxApperances: 0,
+  txApperances: 3,
+  transactions: [
+    '2dc053f55a666a3d2a08b1c680b704d62a55506d14ad884add87edcc56b9277d',
+    '544c15ce35c0f2e808d28f29d6587f1ec9276233e29856b7f2938cf0daef0026',
+    '81039b1d7b855b133f359f9dc65f776bd105650153a941675fedc504228ddbd3'
+  ],
+  legacyAddress: '1Fg4r9iDrEkCcDmHTy2T79EusNfhyQpu7W',
+  cashAddress: 'bitcoincash:qzs02v05l7qs5s24srqju498qu55dwuj0cx5ehjm2c'
+}
+
+const mockUtxoDetails = [
+  {
+    txid: '15f6a584080b04911121fbaca7bfcf3dd64ef2bfa5a01daf31e05a296c3e5e9e',
+    vout: 286,
+    amount: 0.00001,
+    satoshis: 1000,
+    height: 546083,
+    confirmations: 3490
+  },
+  {
+    txid: '15f6a584080b04911121fbaca7bfcf3dd64ef2bfa5a01daf31e05a296c3e5e9e',
+    vout: 287,
+    amount: 0.00001,
+    satoshis: 1000,
+    height: 546083,
+    confirmations: 3490
+  },
+  {
+    txid: '15f6a584080b04911121fbaca7bfcf3dd64ef2bfa5a01daf31e05a296c3e5e9e',
+    vout: 288,
+    amount: 0.00001,
+    satoshis: 1000,
+    height: 546083,
+    confirmations: 3490
+  }
+]
+
+const mockUnconfirmed = [
+  {
+    address: '1EzdL6TBbkNhnB2fYiBaKmcs5fxaoqwdAp',
+    txid: '000c00a90fb5031da6e02f7625df2f8b35a4c16e6feb9fc72293e67e5ff75786',
+    vout: 0,
+    scriptPubKey: '76a914997fabcd94a1e2aaa13a7664362e5e7b96c169a988ac',
+    amount: 0.00999626,
+    satoshis: 999626,
+    confirmations: 0,
+    ts: 1537989425
+  }
+]
+
+const mockTransactions = {
+  pagesTotal: 1,
+  txs: [
+    {
+      txid: '000c00a90fb5031da6e02f7625df2f8b35a4c16e6feb9fc72293e67e5ff75786',
+      version: 2,
+      locktime: 549565,
+      vin: [
+        {
+          txid:
+            '45c891c6d44619fc85716ba1b593aa83ebc1e500fe611b1ab98531ea203a0f21',
+          vout: 209,
+          sequence: 4294967294,
+          n: 0,
+          scriptSig: {
+            hex:
+              '47304402205b136f348bedae61a87c0500979d47ab02c76f0e4aba866b94c4931fccb5d7dc0220757a141660475b0cd4cb8b1f54b1ace95105f5bea775e817b115fb589fe4477541210246daec651c506f353daa7468714399c773df42ac4d663022d0e446a3331ac64a',
+            asm:
+              '304402205b136f348bedae61a87c0500979d47ab02c76f0e4aba866b94c4931fccb5d7dc0220757a141660475b0cd4cb8b1f54b1ace95105f5bea775e817b115fb589fe44775[ALL|FORKID] 0246daec651c506f353daa7468714399c773df42ac4d663022d0e446a3331ac64a'
+          },
+          addr: '14TdovsQUL69xL5g3zSzhLpmDb93d9rU9m',
+          valueSat: 1979534,
+          value: 0.01979534,
+          doubleSpentTxID: null
+        },
+        {
+          txid:
+            '6e5fa79547112a912adf6082c975dc80e282045193512ea369adb6bac7420674',
+          vout: 147,
+          sequence: 4294967294,
+          n: 1,
+          scriptSig: {
+            hex:
+              '473044022056674ac83a37d54ffec2c6d33cfc2ae2256f821b8bd818e1b6783356b49f3d28022046d3dd147c8fc51f2da5d16996a3cea1d7314e327aa1ae1017418737ed20136a4121038f23af565f68d8455e07e5c33c5cfc5114de2f478f035db23eb02f8ff5fe7f6e',
+            asm:
+              '3044022056674ac83a37d54ffec2c6d33cfc2ae2256f821b8bd818e1b6783356b49f3d28022046d3dd147c8fc51f2da5d16996a3cea1d7314e327aa1ae1017418737ed20136a[ALL|FORKID] 038f23af565f68d8455e07e5c33c5cfc5114de2f478f035db23eb02f8ff5fe7f6e'
+          },
+          addr: '1CEtC2fjELvmAzTd6MWuHb1gvuSq8x3Xpb',
+          valueSat: 10466,
+          value: 0.00010466,
+          doubleSpentTxID: null
+        }
+      ],
+      vout: [
+        {
+          value: '0.00999626',
+          n: 0,
+          scriptPubKey: {
+            hex: '76a914997fabcd94a1e2aaa13a7664362e5e7b96c169a988ac',
+            asm:
+              'OP_DUP OP_HASH160 997fabcd94a1e2aaa13a7664362e5e7b96c169a9 OP_EQUALVERIFY OP_CHECKSIG',
+            addresses: ['1EzdL6TBbkNhnB2fYiBaKmcs5fxaoqwdAp'],
+            type: 'pubkeyhash'
+          },
+          spentTxId: null,
+          spentIndex: null,
+          spentHeight: null
+        },
+        {
+          value: '0.00990000',
+          n: 1,
+          scriptPubKey: {
+            hex: '76a914e3335e4d6babe61ea58311293c1c6bfe802801cb88ac',
+            asm:
+              'OP_DUP OP_HASH160 e3335e4d6babe61ea58311293c1c6bfe802801cb OP_EQUALVERIFY OP_CHECKSIG',
+            addresses: ['1MiKvgaQTFCTEZbSDMZgw9ahaB52Cr4ofb'],
+            type: 'pubkeyhash'
+          },
+          spentTxId: null,
+          spentIndex: null,
+          spentHeight: null
+        }
+      ],
+      blockhash:
+        '00000000000000000158b1a2883688873ec5ea076e3b0f576bcdfe1fd277880f',
+      blockheight: 549601,
+      confirmations: 5,
+      time: 1537990026,
+      blocktime: 1537990026,
+      valueOut: 0.01989626,
+      size: 372,
+      valueIn: 0.0199,
+      fees: 0.00000374
+    }
+  ]
+}
+
+module.exports = {
+  mockAddressDetails,
+  mockUtxoDetails,
+  mockUnconfirmed,
+  mockTransactions
+}

test/v4/mocks/bitcore-mock.js

@@ -0,0 +1,35 @@
+/*
+  This library contains mocking data for running unit tests on the bitcore route.
+*/
+
+'use strict'
+
+const mockBalance = {
+  confirmed: 10000000,
+  unconfirmed: 0,
+  balance: 10000000
+}
+
+const mockUtxos = [
+  {
+    _id: '5cf2c31a33bd46a95ec7e730',
+    chain: 'BCH',
+    network: 'testnet',
+    coinbase: false,
+    mintIndex: 1,
+    spentTxid: '',
+    mintTxid:
+      '5fe9b74056319a8c87f45cc745030715a6180758b94938dbf90d639d55652392',
+    mintHeight: 1265275,
+    spentHeight: -2,
+    address: 'qq89kjkeqz9mngp8kl3dpmu43y2wztdjqu500gn4c4',
+    script: '76a9140e5b4ad9008bb9a027b7e2d0ef958914e12db20788ac',
+    value: 10000000,
+    confirmations: -1
+  }
+]
+
+module.exports = {
+  mockBalance,
+  mockUtxos
+}

test/v4/mocks/block-mock.js

@@ -0,0 +1,42 @@
+/*
+  This library contains mocking data for running unit tests on the address route.
+*/
+
+'use strict'
+
+const mockBlockDetails = {
+  hash: '00000000000000645dec6503d3f5eafb0d2537a7a28f181d721dec7c44154c79',
+  size: 1319,
+  height: 1267544,
+  version: 536870912,
+  merkleroot:
+    'c2cd01ec2cf149acc7631385f89ae103d1a2ad212ab810c862d9680a811618ce',
+  tx: [
+    '52bfa89d449fef8070ec33e7a61f5ec8b5417ff62b050cd6a144ebce9557e0fa',
+    '8988e8742d2523f667c2d1374861919e3a82903e059fec75c10795da2303b93b',
+    '41def004f22b196d675566a6983ecf97611e72c48375b8ba779983d5ccd369d7',
+    '8ca8efb06abb94395f8331f87e101504dcf66aee828f2111922f056971fa7502',
+    '9ab409cbb203be7cf22bd6598d787fcdd5b417d885b72207ecc7253470770649'
+  ],
+  time: 1542048973,
+  nonce: 3936284753,
+  bits: '1a03c148',
+  difficulty: 4467892.99177529,
+  chainwork: '00000000000000000000000000000000000000000000003ee27b503a064045bd',
+  confirmations: 3,
+  previousblockhash:
+    '00000000000001891202cbe18729a02a8763cf04da0ca7aded6e6c7d9b500785',
+  nextblockhash:
+    '000000000000039b93b3f3403a0eb21150904b15229d998cf3788fd8bf192cc2',
+  reward: 0.78125,
+  isMainChain: true,
+  poolInfo: {}
+}
+
+const mockBlockHash =
+  '00000000000000645dec6503d3f5eafb0d2537a7a28f181d721dec7c44154c79'
+
+module.exports = {
+  mockBlockDetails,
+  mockBlockHash
+}

test/v4/mocks/blockbook-mock.js

@@ -0,0 +1,75 @@
+/*
+  This library contains mocking data for running unit tests on the blockbook route.
+*/
+
+'use strict'
+
+const mockBalance = {
+  page: 1,
+  totalPages: 1,
+  itemsOnPage: 1000,
+  address: 'bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf',
+  balance: '10000000',
+  totalReceived: '10000000',
+  totalSent: '0',
+  unconfirmedBalance: '0',
+  unconfirmedTxs: 0,
+  txs: 1,
+  txids: ['5fe9b74056319a8c87f45cc745030715a6180758b94938dbf90d639d55652392']
+}
+
+const mockUtxos = [
+  {
+    txid: '5fe9b74056319a8c87f45cc745030715a6180758b94938dbf90d639d55652392',
+    vout: 1,
+    value: '10000000',
+    height: 1265275,
+    confirmations: 42704
+  }
+]
+
+const mockTx = {
+  txid: '5fe9b74056319a8c87f45cc745030715a6180758b94938dbf90d639d55652392',
+  version: 2,
+  vin: [
+    {
+      txid: '85ddb8215fc3701a493cf1c450644c5ef32c55aaa2f48ae2d008944394f3e4d3',
+      sequence: 4294967295,
+      n: 0,
+      addresses: ['bchtest:qqmd9unmhkpx4pkmr6fkrr8rm6y77vckjvqe8aey35'],
+      value: '16983000648',
+      hex:
+        '47304402202378e55f4d02bb932498deef22dfc1f7a4984858c3b55017e225dd567172252e0220373d27710b5d42a72ac9725959f1605a912fee0ae86a7ad36e7d6d796f14ca29412103c346eee77a77a8d3e073dacc0532ca7a5b9747bc06d88bf091cac9f4bc8bb792'
+    }
+  ],
+  vout: [
+    {
+      value: '16973000422',
+      n: 0,
+      spent: true,
+      hex: '76a91436d2f27bbd826a86db1e93618ce3de89ef33169388ac',
+      addresses: ['bchtest:qqmd9unmhkpx4pkmr6fkrr8rm6y77vckjvqe8aey35']
+    },
+    {
+      value: '10000000',
+      n: 1,
+      hex: '76a9140e5b4ad9008bb9a027b7e2d0ef958914e12db20788ac',
+      addresses: ['bchtest:qq89kjkeqz9mngp8kl3dpmu43y2wztdjqu500gn4c4']
+    }
+  ],
+  blockHash: '00000000005242edac4635ac2375a454e801cc1be8b131b622328089731e5e30',
+  blockHeight: 1265275,
+  confirmations: 65402,
+  blockTime: 1540912733,
+  value: '16983000422',
+  valueIn: '16983000648',
+  fees: '226',
+  hex:
+    '0200000001d3e4f394439408d0e28af4a2aa552cf35e4c6450c4f13c491a70c35f21b8dd85000000006a47304402202378e55f4d02bb932498deef22dfc1f7a4984858c3b55017e225dd567172252e0220373d27710b5d42a72ac9725959f1605a912fee0ae86a7ad36e7d6d796f14ca29412103c346eee77a77a8d3e073dacc0532ca7a5b9747bc06d88bf091cac9f4bc8bb792ffffffff02e66eabf3030000001976a91436d2f27bbd826a86db1e93618ce3de89ef33169388ac80969800000000001976a9140e5b4ad9008bb9a027b7e2d0ef958914e12db20788ac00000000'
+}
+
+module.exports = {
+  mockBalance,
+  mockUtxos,
+  mockTx
+}

test/v4/mocks/blockchain-mock.js

@@ -0,0 +1,300 @@
+/*
+  This library contains mocking data for running unit tests on the address route.
+*/
+
+'use strict'
+
+const mockBlockHash =
+  '00000000000000645dec6503d3f5eafb0d2537a7a28f181d721dec7c44154c79'
+
+const mockBlockchainInfo = {
+  chain: 'test',
+  blocks: 1267694,
+  headers: 1267694,
+  bestblockhash:
+    '000000000000013eaf80d1e157e32804c36a58ad0bb26ca59833880c80298780',
+  difficulty: 4105763.969035785,
+  mediantime: 1542131305,
+  verificationprogress: 0.9999968911571566,
+  chainwork: '00000000000000000000000000000000000000000000003f0443b0b5f02ce255',
+  pruned: false,
+  softforks: [
+    { id: 'bip34', version: 2, reject: { status: true } },
+    { id: 'bip66', version: 3, reject: { status: true } },
+    { id: 'bip65', version: 4, reject: { status: true } }
+  ],
+  bip9_softforks: {
+    csv: {
+      status: 'active',
+      startTime: 1456790400,
+      timeout: 1493596800,
+      since: 770112
+    }
+  }
+}
+
+const mockChainTips = [
+  {
+    height: 1267696,
+    hash: '000000000000035bfc43a642ebbff8cfc1e88b1d564de8b0a6c7e2797eeafb21',
+    branchlen: 0,
+    status: 'active'
+  },
+  {
+    height: 1267581,
+    hash: '000000000001bd12e4124207682563135b21353ca3087bc6b0c409f7f9e1da91',
+    branchlen: 1,
+    status: 'valid-fork'
+  },
+  {
+    height: 1267375,
+    hash: '00000000702036979df70236bcc45dfc72d43d5d0e6834007afa1fa627e49587',
+    branchlen: 1036,
+    status: 'headers-only'
+  },
+  {
+    height: 1266979,
+    hash: '00000000e851abbde2174ccdc5c2508b909f81f23c4b7abeac864eee1a4891c7',
+    branchlen: 1,
+    status: 'valid-fork'
+  },
+  {
+    height: 1266973,
+    hash: '000000007e1324d2900ed70947f89ab8fd4a267e87c9244c333215659a7370d5',
+    branchlen: 1,
+    status: 'valid-fork'
+  },
+  {
+    height: 1266967,
+    hash: '000000000f37f12843d4800f50ec4de44dce0432e4d448242d43ff04a7a2948d',
+    branchlen: 1,
+    status: 'valid-fork'
+  },
+  {
+    height: 1266963,
+    hash: '00000000ae11ec99e88898cbd72567cb4cb79e7fc13243357bef79632769deb4',
+    branchlen: 1,
+    status: 'valid-fork'
+  },
+  {
+    height: 1266962,
+    hash: '000000004f97851259b4460a049e44fa5bd4beadee04a85bf81bd2e90c4f24f9',
+    branchlen: 1,
+    status: 'valid-fork'
+  },
+  {
+    height: 1266950,
+    hash: '00000000d12a0e4a827f73ecaadb563df7e99817294939f2be8e943079dc60b2',
+    branchlen: 1,
+    status: 'valid-fork'
+  },
+  {
+    height: 1266944,
+    hash: '00000000612d16af273217818e8e7ac5014a19f68ed04e1bc897b1be0a9c744f',
+    branchlen: 1,
+    status: 'valid-fork'
+  },
+  {
+    height: 1266941,
+    hash: '0000000000002b91cdb15cacf3368da2c9ffce511d64092193b507dad75f4a27',
+    branchlen: 1,
+    status: 'valid-fork'
+  },
+  {
+    height: 1266896,
+    hash: '000000000002745f67a66617b1f9f65c2dfb4c4b8a9ed9b1320b98d3ca46cbe5',
+    branchlen: 1,
+    status: 'valid-fork'
+  },
+  {
+    height: 1266481,
+    hash: '0000000000036babee3ba7654cddb29a9fe5e85c9fbeb44bb53d5ffb694b9670',
+    branchlen: 1,
+    status: 'valid-fork'
+  },
+  {
+    height: 1266452,
+    hash: '00000000502c3ab1490e0839780a4b441bbe21507c454545941e6adcde73c2ff',
+    branchlen: 1,
+    status: 'valid-fork'
+  },
+  {
+    height: 1266336,
+    hash: '000000001c9a0b7cd9eb2210f69d5a9a3f4546ba3707deb40993d729190582d7',
+    branchlen: 10,
+    status: 'headers-only'
+  },
+  {
+    height: 1266097,
+    hash: '000000000028ac0fbd18afe6f001f70cb7549bd2b3082d754dde88ee236368a2',
+    branchlen: 1,
+    status: 'valid-fork'
+  },
+  {
+    height: 1265522,
+    hash: '00000000000000c6df7a2063030e6ce51399e470cc46e4bf6d67aa3f0feca98d',
+    branchlen: 1,
+    status: 'valid-fork'
+  },
+  {
+    height: 1265470,
+    hash: '0000000000168e6442a595a02340fccf8dc2b0e8912c632d39e1f870685f6d7c',
+    branchlen: 2,
+    status: 'valid-fork'
+  },
+  {
+    height: 1265275,
+    hash: '000000008bc2b37ae6af1b886b52e7e1c1122c12badc4ae6c13df64f789267cf',
+    branchlen: 11027,
+    status: 'headers-only'
+  },
+  {
+    height: 1265257,
+    hash: '00000000005bc3e9973d7273211eab02ae02549c7ebae48764c0bd648d4d7bbe',
+    branchlen: 114,
+    status: 'valid-fork'
+  },
+  {
+    height: 1265254,
+    hash: '0000000000e5b909d3541857315e9ee103b042d9ba661f25cc3e8fb25a96c8ce',
+    branchlen: 111,
+    status: 'valid-fork'
+  },
+  {
+    height: 1265245,
+    hash: '000000000066eb8832f6f990baceb379536f437216e22475a6c1b9133d250cb8',
+    branchlen: 102,
+    status: 'valid-fork'
+  },
+  {
+    height: 1264455,
+    hash: '00000000000001befc1bb17a23208d0b77b2449e37093ce8fbb5e346b19cafcc',
+    branchlen: 1,
+    status: 'valid-headers'
+  },
+  {
+    height: 1264373,
+    hash: '00000000000001ed3747e04fb95054cac0358fb4d8009d1999fc3ea34413e84a',
+    branchlen: 175,
+    status: 'valid-fork'
+  },
+  {
+    height: 1263912,
+    hash: '00000000000004635aecbcb97edcd6f5396483338838cb40da804eb354c68bde',
+    branchlen: 1,
+    status: 'valid-fork'
+  },
+  {
+    height: 1262906,
+    hash: '00000000b31643d92a3e7c38e9755844fc8607e3f1055580a8ff28854e8a8ece',
+    branchlen: 1,
+    status: 'valid-fork'
+  },
+  {
+    height: 1255749,
+    hash: '000000001dde5b015a99137f4cba87871370f4b6fcfbcc8b126547e6c33177da',
+    branchlen: 129,
+    status: 'headers-only'
+  },
+  {
+    height: 1188789,
+    hash: '00000000af942ce4eb60b3213cbcb7c98a7330f1f8f1adb4b6376f5e822e15b2',
+    branchlen: 92,
+    status: 'headers-only'
+  }
+]
+
+const mockMempoolInfo = {
+  size: 87,
+  bytes: 16816,
+  usage: 66408,
+  maxmempool: 300000000,
+  mempoolminfee: 0
+}
+
+const mockRawMempool = [
+  'db045bc3bd1088fa91f5ebb05c35cb9e2a91a22377f79b465cc6920b9893123c',
+  '6b3df7febf2b9834f1409155f88b866dd516b36376eae00e2b455df82e290405'
+]
+
+const mockBlockHeaderConcise =
+  '000000202ed2723e7590e2b937f6821a99d6764cb8799bf30f8e300000000000000000001d311c02df9a1e3f57b8dbdcf97ec8dbc3109a26779724c63e560b29ad9ea501e2af955d286403183049e39c'
+
+const mockBlockHeader = {
+  hash: '00000000000008c3679777df34f1a09565f98b2400a05b7c8da72525fdca3900',
+  confirmations: 7,
+  height: 1272859,
+  version: 2147418112,
+  versionHex: '7fff0000',
+  merkleroot:
+    '846f45604ec6cde2528933305dba80971e9ff0874f74d2811c7c690b2c32706d',
+  time: 1544207139,
+  mediantime: 1544202884,
+  nonce: 641041470,
+  bits: '1a09faea',
+  difficulty: 1681035.704111868,
+  chainwork: '00000000000000000000000000000000000000000000003fc4752e608403be04',
+  previousblockhash:
+    '0000000000003e467ebcb7e906645676c2f71b9ac520d6508bea45789b7c217d',
+  nextblockhash:
+    '00000000000006899041cdfd6c0b73a97730c362346dde479b77414ad7f25ace',
+  nTx: 'some value'
+}
+
+const mockTxOut = {
+  bestblock: '00000000003a7f19730dd9f172d7466658a5c8833dd03ed8f4ba36e3d857b5e7',
+  confirmations: 10,
+  value: 0.0001,
+  scriptPubKey: {
+    asm:
+      'OP_DUP OP_HASH160 0ee020c07f39526ac5505c54fa1ab98490979b83 OP_EQUALVERIFY OP_CHECKSIG',
+    hex: '76a9140ee020c07f39526ac5505c54fa1ab98490979b8388ac',
+    reqSigs: 1,
+    type: 'pubkeyhash',
+    addresses: ['bchtest:qq8wqgxq0uu4y6k92pw9f7s6hxzfp9umsvtg39pzqf']
+  },
+  coinbase: false
+}
+
+const mockTxOutProof =
+  '000000200798039affceb7a381e15dc62443c286efe7cae852393b656807000000000000cf9a7d6c654fd1c4558229a619a550ff749b373fa0f0027eed68b1abf6175d5c07c50f5cffff001d0452403b34000000070d0765da76980d542b5670d27ccda9e717073270f8921ad017deb7ee83fe6c4c22830a48cc8392197f1742a3d81805bd2aa4eb7469f38c74f674429d682cb87efcff1713fd0c388a50f0d11adf05363397ef79d16cdb786d47c941c2cb89f2588f42aced9c05f4203b4440616a9e4266ec47909b9580a643f402b5d4e82cc3cddd73df05a33abf6af3975d973d3033d10c4168a73d58d01f685a96d5a2519cd0de9c77faf3f8725ddf155cbdc8ab8102f173e2d0a0d74767f3bff22f588158d6d5bc71c079c7659cc864819c43877635007650502eb4060fcc9feec3280a41d602ad0a'
+
+const mockAncestors = [
+  '070504de968fba8a23a1362fd7fc0546a420663f2bcc18099d894a41ecf9cce5',
+  '20af6b7fcd21a3f38bb65d32fe2d66fb1ae554ed9c00eaf1b17d7e81362381a9',
+  '227e08663a812cf44d91106b09fc8493fe1a2b7c146f30ca09ebd86c9b84b2a5',
+  '228833be79d4a833165ea199be160efcaeb9325e71e9455f424b27abc9688ba8',
+  '2de27df02001e7243435cef6d41ea2312b94a5964912eb21466b936852c0b822',
+  '2ef76ae690d6f6c9559e20358a75a0ce02250b9b8e80e0aa6f782576239f292a',
+  '3e314678f52d52694726e6da88b94c9f0ea086d2f9af297b01d014b62247839f',
+  '4773f840d5255f16c0e5effce48316d8b8824a1d3ddd5da275c5fd99e7b3ee42',
+  '4804b97112da07e2c187516a915dd4cbd4a3814f3c900b8d08eb1d508ab0ac47',
+  '4ca69f31081a256cb4711315336fe4358d8f04b67792ca5ee17b5f4089a2446a',
+  '6ac17dce10ae3a3d1d8e6f42546ad9a4bb981e62cba8d48bab03e01b9ea38ae3',
+  '6ce71182ef341c481a90d8b081a99d9788bdd91a917f9a6594fdfad2c2024a14',
+  '8413343ac973fb0968ae1809faa8f0ddf18252975481daa683e88b04afa66ccd',
+  '9430300f3d7ecdabe39671b6fd0e9c36f763f01a202e619c070554ddc5e8713e',
+  '94f82b5a2cd1647d8168807ccfdebe41931ea1ab789a050d615f08000a63b624',
+  '9848db6a7d2835002ca7e1097a685d75eb629f44df94007674635b45d0e97199',
+  '98d809993353df6c4d55fda5e7b0ed2e383601cef1180a9aa9c87e67e8f4dd94',
+  '9f5513a35ae8fad3dd061865a97d8127c914e3464527641c089993c06d092535',
+  'a7201ac90abd2aa42112faa809181c45047b6988a2f649a70a1d5bfb95f46884',
+  'a9f1284710c655357412a062b01efaeb174820613784ccbfe44b33b86a8bdbc4',
+  'b814f44c9c8ee24a218b9f295a8c1831106b70c15ffe8aeb7534e10d99935fd0',
+  'e130ccdcc94dc5eaa4ae37fa50e3ee96283b0e157616bc6e28454b64bae34f48',
+  'e68dad4a7292105cfa84fcaef7f99e5d4f2ece9613ca625d4d2ebf61efa84118',
+  'fe94caf5da672be3772d2304a6272eb8bc3d3f5cb4a886f39b7981e1485cf74b'
+]
+
+module.exports = {
+  mockBlockHash,
+  mockBlockchainInfo,
+  mockChainTips,
+  mockMempoolInfo,
+  mockRawMempool,
+  mockBlockHeaderConcise,
+  mockBlockHeader,
+  mockTxOut,
+  mockTxOutProof,
+  mockAncestors
+}

test/v4/mocks/control-mock.js

@@ -0,0 +1,45 @@
+/*
+  This library contains mocking data for running unit tests on the address route.
+*/
+
+'use strict'
+
+const mockGetInfo = {
+  version: 170200,
+  protocolversion: 70015,
+  walletversion: 160300,
+  balance: 0,
+  blocks: 1266726,
+  timeoffset: 0,
+  connections: 8,
+  proxy: '',
+  difficulty: 1,
+  testnet: true,
+  keypoololdest: 1536331195,
+  keypoolsize: 2000,
+  paytxfee: 0,
+  relayfee: 0.00001,
+  errors: 'Warning: unknown new rules activated (versionbit 28)'
+}
+
+const mockGetNetworkInfo = {
+  version: 190700,
+  subversion: '/Bitcoin ABC:0.19.7(EB32.0)/',
+  protocolversion: 70015,
+  localservices: '0000000000000425',
+  localrelay: true,
+  timeoffset: 0,
+  networkactive: true,
+  connections: 23,
+  networks: [{}, {}, {}],
+  relayfee: 0.00001,
+  excessutxocharge: 0,
+  localaddresses: [],
+  warnings:
+    "Warning: Unknown block versions being mined! It's possible unknown rules are in effect"
+}
+
+module.exports = {
+  mockGetInfo,
+  mockGetNetworkInfo
+}

test/v4/mocks/electrumx-mock.js

@@ -0,0 +1,122 @@
+/*
+  Mocking data for electrumx unit tests
+*/
+
+'use strict'
+
+const utxos = [
+  {
+    height: 604392,
+    tx_hash: '7774e449c5a3065144cefbc4c0c21e6b69c987f095856778ef9f45ddd8ae1a41',
+    tx_pos: 0,
+    value: 1000
+  },
+  {
+    height: 630834,
+    tx_hash: '4fe60a51e0d8f5134bfd8e5f872d6e502d7f01b28a6afebb27f4438a4f638d53',
+    tx_pos: 0,
+    value: 6000
+  }
+]
+
+const balance = {
+  confirmed: 7000,
+  unconfirmed: 0
+}
+
+const txHistory = [
+  {
+    height: 601861,
+    tx_hash: '6181c669614fa18039a19b23eb06806bfece1f7514ab457c3bb82a40fe171a6d'
+  }
+]
+
+const mempool = [
+  {
+    tx_hash: '45381031132c57b2ff1cbe8d8d3920cf9ed25efd9a0beb764bdb2f24c7d1c7e3',
+    height: 0,
+    fee: 24310
+  }
+]
+
+const txDetails = {
+  blockhash: '0000000000000000002aaf94953da3b487317508ebd1003a1d75d6d6ec2e75cc',
+  blocktime: 1578327094,
+  confirmations: 31861,
+  hash: '4db095f34d632a4daf942142c291f1f2abb5ba2e1ccac919d85bdc2f671fb251',
+  hex: '020000000265d13ef402840c8a51f39779afb7ae4d49e4b0a3c24a3d0e7742038f2c679667010000006441dd1dd72770cadede1a7fd0363574846c48468a398ddfa41a9677c74cac8d2652b682743725a3b08c6c2021a629011e11a264d9036e9d5311e35b5f4937ca7b4e4121020797d8fd4d2fa6fd7cdeabe2526bfea2b90525d6e8ad506ec4ee3c53885aa309ffffffff65d13ef402840c8a51f39779afb7ae4d49e4b0a3c24a3d0e7742038f2c679667000000006441347d7f218c11c04487c1ad8baac28928fb10e5054cd4494b94d078cfa04ccf68e064fb188127ff656c0b98e9ce87f036d183925d0d0860605877d61e90375f774121028a53f95eb631b460854fc836b2e5d31cad16364b4dc3d970babfbdcc3f2e4954ffffffff035ac355000000000017a914189ce02e332548f4804bac65cba68202c9dbf822878dfd0800000000001976a914285bb350881b21ac89724c6fb6dc914d096cd53b88acf9ef3100000000001976a91445f1f1c4a9b9419a5088a3e9c24a293d7a150e6488ac00000000',
+  locktime: 0,
+  size: 392,
+  time: 1578327094,
+  txid: '4db095f34d632a4daf942142c291f1f2abb5ba2e1ccac919d85bdc2f671fb251',
+  version: 2,
+  vin: [
+    {
+      scriptSig: {
+        asm: 'dd1dd72770cadede1a7fd0363574846c48468a398ddfa41a9677c74cac8d2652b682743725a3b08c6c2021a629011e11a264d9036e9d5311e35b5f4937ca7b4e[ALL|FORKID] 020797d8fd4d2fa6fd7cdeabe2526bfea2b90525d6e8ad506ec4ee3c53885aa309',
+        hex: '41dd1dd72770cadede1a7fd0363574846c48468a398ddfa41a9677c74cac8d2652b682743725a3b08c6c2021a629011e11a264d9036e9d5311e35b5f4937ca7b4e4121020797d8fd4d2fa6fd7cdeabe2526bfea2b90525d6e8ad506ec4ee3c53885aa309'
+      },
+      sequence: 4294967295,
+      txid: '6796672c8f0342770e3d4ac2a3b0e4494daeb7af7997f3518a0c8402f43ed165',
+      vout: 1
+    },
+    {
+      scriptSig: {
+        asm: '347d7f218c11c04487c1ad8baac28928fb10e5054cd4494b94d078cfa04ccf68e064fb188127ff656c0b98e9ce87f036d183925d0d0860605877d61e90375f77[ALL|FORKID] 028a53f95eb631b460854fc836b2e5d31cad16364b4dc3d970babfbdcc3f2e4954',
+        hex: '41347d7f218c11c04487c1ad8baac28928fb10e5054cd4494b94d078cfa04ccf68e064fb188127ff656c0b98e9ce87f036d183925d0d0860605877d61e90375f774121028a53f95eb631b460854fc836b2e5d31cad16364b4dc3d970babfbdcc3f2e4954'
+      },
+      sequence: 4294967295,
+      txid: '6796672c8f0342770e3d4ac2a3b0e4494daeb7af7997f3518a0c8402f43ed165',
+      vout: 0
+    }
+  ],
+  vout: [
+    {
+      n: 0,
+      scriptPubKey: {
+        addresses: ['bitcoincash: pqvfecpwxvj53ayqfwkxtjaxsgpvnklcyg8xewk9hl'],
+        asm: 'OP_HASH160 189ce02e332548f4804bac65cba68202c9dbf822 OP_EQUAL',
+        hex: 'a914189ce02e332548f4804bac65cba68202c9dbf82287',
+        reqSigs: 1,
+        type: 'scripthash'
+      },
+      value: 0.0562057
+    },
+    {
+      n: 1,
+      scriptPubKey: {
+        addresses: ['bitcoincash: qq59hv6s3qdjrtyfwfxxldkuj9xsjmx48vrz882knz'],
+        asm: 'OP_DUP OP_HASH160 285bb350881b21ac89724c6fb6dc914d096cd53b OP_EQUALVERIFY OP_CHECKSIG',
+        hex: '76a914285bb350881b21ac89724c6fb6dc914d096cd53b88ac',
+        reqSigs: 1,
+        type: 'pubkeyhash'
+      },
+      value: 0.00589197
+    },
+    {
+      n: 2,
+      scriptPubKey: {
+        addresses: ['bitcoincash: qpzlruwy4xu5rxjs3z37nsj29y7h59gwvsu4ddp0u4'],
+        asm: 'OP_DUP OP_HASH160 45f1f1c4a9b9419a5088a3e9c24a293d7a150e64 OP_EQUALVERIFY OP_CHECKSIG',
+        hex: '76a91445f1f1c4a9b9419a5088a3e9c24a293d7a150e6488ac',
+        reqSigs: 1,
+        type: 'pubkeyhash'
+      },
+      value: 0.03272697
+    }
+  ]
+}
+
+const blockHeaders = [
+  '010000008b52bbd72c2f49569059f559c1b1794de5192e4f7d6d2b03c7482bad0000000083e4f8a9d502ed0c419075c1abb5d56f878a2e9079e5612bfb76a2dc37d9c42741dd6849ffff001d2b909dd6',
+  '01000000f528fac1bcb685d0cd6c792320af0300a5ce15d687c7149548904e31000000004e8985a786d864f21e9cbb7cbdf4bc9265fe681b7a0893ac55a8e919ce035c2f85de6849ffff001d385ccb7c'
+]
+
+module.exports = {
+  utxos,
+  balance,
+  txHistory,
+  mempool,
+  txDetails,
+  blockHeaders
+}

test/v4/mocks/encryption-mocks.js

@@ -0,0 +1,182 @@
+/*
+  Mock data for the encryption test library
+*/
+
+const mockNoSendTx = {
+  txid: 'a3b62cd4f4c56ba52139179db14bffd4ab22a2e077f3c62bd5cf0541bfcaf023',
+  hash: 'a3b62cd4f4c56ba52139179db14bffd4ab22a2e077f3c62bd5cf0541bfcaf023',
+  version: 2,
+  size: 226,
+  locktime: 0,
+  vin: [
+    {
+      txid: '681cc1d392975a7e78cbd490b8a940d7eb029c554f2cee332e3a7119d77fb189',
+      vout: 1,
+      scriptSig: {
+        asm:
+          '30450221008a7c86ce3a9f5765573440143a00631bb5afa9a58b24674a7fa794bb11ffffc30220397dd4c672c3e0dbe0c4eb6390b5727c5fdc3a42cf3ae275ac13b44d27bb234f[ALL|FORKID] 02bc9fc26ae2bd9a9a14e9baeda4b4fdd95a00bcbf375732c647488b3ce82a2fd7',
+        hex:
+          '4830450221008a7c86ce3a9f5765573440143a00631bb5afa9a58b24674a7fa794bb11ffffc30220397dd4c672c3e0dbe0c4eb6390b5727c5fdc3a42cf3ae275ac13b44d27bb234f412102bc9fc26ae2bd9a9a14e9baeda4b4fdd95a00bcbf375732c647488b3ce82a2fd7'
+      },
+      sequence: 4294967295
+    }
+  ],
+  vout: [
+    {
+      value: 0.000006,
+      n: 0,
+      scriptPubKey: {
+        asm:
+          'OP_DUP OP_HASH160 3c79ba54317c4be9cbfa5aaf357f74b97f3d9696 OP_EQUALVERIFY OP_CHECKSIG',
+        hex: '76a9143c79ba54317c4be9cbfa5aaf357f74b97f3d969688ac',
+        reqSigs: 1,
+        type: 'pubkeyhash',
+        addresses: ['bitcoincash:qq78nwj5x97yh6wtlfd27dtlwjuh70vkjc59h8tgtg']
+      }
+    },
+    {
+      value: 0.00003664,
+      n: 1,
+      scriptPubKey: {
+        asm:
+          'OP_DUP OP_HASH160 58502a73888e0a386fc69b44850af4b2a86ac9a6 OP_EQUALVERIFY OP_CHECKSIG',
+        hex: '76a91458502a73888e0a386fc69b44850af4b2a86ac9a688ac',
+        reqSigs: 1,
+        type: 'pubkeyhash',
+        addresses: ['bitcoincash:qpv9q2nn3z8q5wr0c6d5fpg27je2s6kf5cavp4ney0']
+      }
+    }
+  ],
+  hex:
+    '020000000189b17fd719713a2e33ee2c4f559c02ebd740a9b890d4cb787e5a9792d3c11c68010000006b4830450221008a7c86ce3a9f5765573440143a00631bb5afa9a58b24674a7fa794bb11ffffc30220397dd4c672c3e0dbe0c4eb6390b5727c5fdc3a42cf3ae275ac13b44d27bb234f412102bc9fc26ae2bd9a9a14e9baeda4b4fdd95a00bcbf375732c647488b3ce82a2fd7ffffffff0258020000000000001976a9143c79ba54317c4be9cbfa5aaf357f74b97f3d969688ac500e0000000000001976a91458502a73888e0a386fc69b44850af4b2a86ac9a688ac00000000'
+}
+
+const mockFulcrumTxHistory = {
+  success: true,
+  transactions: [
+    {
+      height: 511463,
+      tx_hash:
+        'eff00a9538487ff44243c75fb13de19b5783454c42c81b9aff9afbfd09cbaec3'
+    },
+    {
+      height: 511464,
+      tx_hash:
+        '7e9aa7a74de2b30200a2d6fc748ff35a0c753221444194f720bb7f61ef1d9153'
+    },
+    {
+      height: 513373,
+      tx_hash:
+        '6960255abe64893073921e96bf3c053c82686e0fc22a565494fbe2a31e766975'
+    },
+    {
+      height: 513373,
+      tx_hash:
+        '9ea667bcfc9cd337bd6c5583d8094c1b1942bd2015d95b54189deac5070eeff0'
+    },
+    {
+      height: 560481,
+      tx_hash:
+        'ecc1b51bac767880382bf3190ff17abf78d0936843a022a943d871116ed50368'
+    },
+    {
+      height: 560615,
+      tx_hash:
+        'b3792d28377b975560e1b6f09e48aeff8438d4c6969ca578bd406393bd50bd7d'
+    },
+    {
+      height: 561568,
+      tx_hash:
+        '8bc2134c7e48e56e1769b3d7c4c1e3a0acc68e1e58160eee6fa67f3208c07262'
+    },
+    {
+      height: 561569,
+      tx_hash:
+        'ceb0cab0e37b59caf3ca29e1a698d19ff47f2827dd09cb2f3b91b9100b1dad1c'
+    },
+    {
+      height: 561572,
+      tx_hash:
+        '0f9b49cafeb9ae1d741cdb12137c92816aa8470944c270a78ba2e610bd59190d'
+    },
+    {
+      height: 561582,
+      tx_hash:
+        'e4a0ac48ff3f42fc342717a2a3d34248e5e85bae79d59bd20e1b60e61b1c500f'
+    },
+    {
+      height: 562106,
+      tx_hash:
+        '1afcc63b244182647909539ebe3f4a44b8ea4120a95edb8d9eebe5347b9491bb'
+    },
+    {
+      height: 562106,
+      tx_hash:
+        'c42f8f16d3baa2ee343ea89ef110dfe094992379d08edd30887b8ca7ee671c9a'
+    }
+  ]
+}
+
+const mockTxDetails2 = {
+  txid: '7e9aa7a74de2b30200a2d6fc748ff35a0c753221444194f720bb7f61ef1d9153',
+  hash: '7e9aa7a74de2b30200a2d6fc748ff35a0c753221444194f720bb7f61ef1d9153',
+  version: 1,
+  size: 221,
+  locktime: 0,
+  vin: [
+    {
+      txid: 'eff00a9538487ff44243c75fb13de19b5783454c42c81b9aff9afbfd09cbaec3',
+      vout: 0,
+      scriptSig: {
+        asm:
+          '30440220150e7c9b646fe1f7f576456c9808c89a710e8fbb753e9f5ca6ed2d39a0b69ba602202212968163d8dfe35eec5975fce38440082029cb2691a3e0ad1714f9c412c47a[ALL|FORKID] 044eb40b025df18409f2a5197b010dd62a9e65d9a74e415e5b10367721a9c4baa7ebfee22d14b8ece1c9bd70c0d9e5e8b00b61b81b88a1b5ce6f24eac6b8a34b2c',
+        hex:
+          '4730440220150e7c9b646fe1f7f576456c9808c89a710e8fbb753e9f5ca6ed2d39a0b69ba602202212968163d8dfe35eec5975fce38440082029cb2691a3e0ad1714f9c412c47a4141044eb40b025df18409f2a5197b010dd62a9e65d9a74e415e5b10367721a9c4baa7ebfee22d14b8ece1c9bd70c0d9e5e8b00b61b81b88a1b5ce6f24eac6b8a34b2c'
+      },
+      sequence: 4294967295
+    }
+  ],
+  vout: [
+    {
+      value: 0.01266023,
+      n: 0,
+      scriptPubKey: {
+        asm: 'OP_HASH160 91bacd6785e3f8c78d5f29b4020b94c753444130 OP_EQUAL',
+        hex: 'a91491bacd6785e3f8c78d5f29b4020b94c75344413087',
+        reqSigs: 1,
+        type: 'scripthash',
+        addresses: ['bitcoincash:pzgm4nt8sh3l33udtu5mgqstjnr4x3zpxqrrrndnw5']
+      }
+    }
+  ],
+  hex:
+    '0100000001c3aecb09fdfb9aff9a1bc8424c4583579be13db15fc74342f47f4838950af0ef000000008a4730440220150e7c9b646fe1f7f576456c9808c89a710e8fbb753e9f5ca6ed2d39a0b69ba602202212968163d8dfe35eec5975fce38440082029cb2691a3e0ad1714f9c412c47a4141044eb40b025df18409f2a5197b010dd62a9e65d9a74e415e5b10367721a9c4baa7ebfee22d14b8ece1c9bd70c0d9e5e8b00b61b81b88a1b5ce6f24eac6b8a34b2cffffffff01675113000000000017a91491bacd6785e3f8c78d5f29b4020b94c7534441308700000000',
+  blockhash: '000000000000000001aab6818b4ad0379a3f7a13940d9b3d4838b3dea1d0a083',
+  confirmations: 149222,
+  time: 1515088493,
+  blocktime: 1515088493
+}
+
+const mockFulcrumNoTxHistory = {
+  success: true,
+  transactions: []
+}
+
+const mockFulcrumNoSendBalance = {
+  success: true,
+  transactions: [
+    {
+      height: 633578,
+      tx_hash:
+        'a3b62cd4f4c56ba52139179db14bffd4ab22a2e077f3c62bd5cf0541bfcaf023'
+    }
+  ]
+}
+
+module.exports = {
+  mockNoSendTx,
+  mockFulcrumTxHistory,
+  mockTxDetails2,
+  mockFulcrumNoTxHistory,
+  mockFulcrumNoSendBalance
+}

test/v4/mocks/express-mocks.js

@@ -0,0 +1,89 @@
+/*
+  Contains mocks of Express req and res objects.
+*/
+
+'use strict'
+
+const sinon = require('sinon')
+
+// Inspect JS Objects.
+const util = require('util')
+util.inspect.defaultOptions = {
+  showHidden: true,
+  colors: true
+}
+
+// mock for res.send()
+function fakeSend (arg) {
+  // console.log(`res.send: ${util.inspect(arg)}`);
+  mockRes.output = arg
+  return arg
+}
+
+// mock for res.json()
+function fakeJson (arg) {
+  // console.log(`res.json: ${util.inspect(arg)}`);
+  mockRes.output = arg
+  return arg
+}
+
+// mock for res.setStatus(num)
+const setStatusCode = arg => {
+  mockRes.statusCode = arg
+}
+
+const mockReq = {
+  accepts: sinon.stub().returns({}),
+  acceptsCharsets: sinon.stub().returns({}),
+  acceptsEncodings: sinon.stub().returns({}),
+  acceptsLanguages: sinon.stub().returns({}),
+  body: {},
+  flash: sinon.stub().returns({}),
+  get: sinon.stub().returns({}),
+  is: sinon.stub().returns({}),
+  params: {},
+  query: {},
+  session: {},
+  locals: {},
+  headers: {}
+}
+
+const mockRes = {
+  append: sinon.stub().returns({}),
+  attachement: sinon.stub().returns({}),
+  clearCookie: sinon.stub().returns({}),
+  cookie: sinon.stub().returns({}),
+  download: sinon.stub().returns({}),
+  end: sinon.stub().returns({}),
+  get: sinon.stub().returns({}),
+  headersSent: sinon.stub().returns({}),
+  json: sinon.stub().callsFake(fakeJson),
+  jsonp: sinon.stub().returns({}),
+  links: sinon.stub().returns({}),
+  locals: {},
+  location: sinon.stub().returns({}),
+  output: null, // Used for retrieving output data.
+  redirect: sinon.stub().returns({}),
+  render: sinon.stub().returns({}),
+  send: sinon.stub().callsFake(fakeSend),
+  sendFile: sinon.stub().returns({}),
+  sendStatus: sinon.stub().returns({}),
+  set: sinon.stub().returns({}),
+  status: sinon.stub().callsFake(setStatusCode),
+  statusCode: null, // Default value before calling stats();
+  type: sinon.stub().returns({}),
+  vary: sinon.stub().returns({}),
+  write: sinon.stub().returns({}),
+  setHeader: sinon.stub().returns({}),
+  format: sinon.stub().returns({})
+}
+
+// Dev-Note on Rate Limits: Since next() is mocked, I can call the Sinon untility
+// functions on it, like called(), to see if this stub was called.
+const mockNext = sinon.stub().returns()
+
+module.exports = {
+  mockReq,
+  mockRes,
+  mockNext
+}

test/v4/mocks/mining-mocks.js

@@ -0,0 +1,21 @@
+/*
+  This library contains mocking data for running unit tests on the address route.
+*/
+
+'use strict'
+
+const mockMiningInfo = {
+  blocks: 1270185,
+  currentblocksize: 0,
+  currentblocktx: 0,
+  difficulty: 1,
+  warnings:
+    "Warning: Unknown block versions being mined! It's possible unknown rules are in effect",
+  networkhashps: 517410290.9365583,
+  pooledtx: 5,
+  chain: 'test'
+}
+
+module.exports = {
+  mockMiningInfo
+}

test/v4/mocks/price-mock.js

@@ -0,0 +1,241 @@
+/*
+  This library contains mocking data for running unit tests on the address route.
+*/
+
+'use strict'
+
+const mockCoinbaseFeed = {
+  data: {
+    currency: 'BCH',
+    rates: {
+      AED: '918.11634',
+      AFN: '19208.6584998',
+      ALGO: '823.28722002635056355',
+      ALL: '26365.4673517',
+      AMD: '120379.9761886',
+      ANG: '448.6632494',
+      AOA: '162813.68075',
+      ARS: '19392.84240565',
+      ATOM: '45.3670932026499700525',
+      AUD: '354.4385981',
+      AWG: '449.91',
+      AZN: '425.539875',
+      BAL: '18.824215193276753072',
+      BAM: '415.45514235',
+      BAND: '40.7768732564399590085',
+      BAT: '1168.9711697428450012',
+      BBD: '499.9',
+      BCH: '1.0',
+      BDT: '21194.1523216',
+      BGN: '415.36691',
+      BHD: '94.2501462',
+      BIF: '483670.78174295',
+      BMD: '249.95',
+      BND: '339.227141',
+      BOB: '1725.8732563',
+      BRL: '1401.494645',
+      BSD: '249.95',
+      BSV: '1.567361207606150942625',
+      BTC: '0.021275',
+      BTN: '18323.91073475',
+      BWP: '2859.81217315',
+      BYN: '640.5913561',
+      BYR: '6405913.561',
+      BZD: '503.8107177',
+      CAD: '329.6765515',
+      CDF: '490377.5463717',
+      CGLD: '121.6805004503079241715',
+      CHF: '227.5939721',
+      CLF: '7.13432285',
+      CLP: '196860.63474705',
+      CNH: '1669.50978125',
+      CNY: '1670.21589',
+      COMP: '2.429765723728978241',
+      COP: '961722.29431455',
+      CRC: '150790.4338804',
+      CUC: '250.01273745',
+      CVE: '23620.275',
+      CZK: '5790.09175',
+      DAI: '247.842348666936355635',
+      DASH: '3.338230383973288798',
+      DJF: '44495.8985401',
+      DKK: '1580.608815',
+      DOP: '14597.4179324',
+      DZD: '32214.830745',
+      EEK: '3652.69206545',
+      EGP: '3924.839875',
+      EOS: '96.8423091824874092665',
+      ERN: '3749.25274945',
+      ETB: '9313.6508972',
+      ETC: '45.04821122825989111',
+      ETH: '0.658777328255340453815',
+      EUR: '212.33',
+      FJD: '534.9054975',
+      FKP: '193.01413945',
+      GBP: '193.115',
+      GEL: '807.3385',
+      GGP: '193.01413945',
+      GHS: '1453.70845015',
+      GIP: '193.01413945',
+      GMD: '12934.9125',
+      GNF: '2447970.79115335',
+      GTQ: '1944.576007',
+      GYD: '52260.2868518',
+      HKD: '1937.122498',
+      HNL: '6129.328889',
+      HRK: '1610.802775',
+      HTG: '15746.55080985',
+      HUF: '77512.6058777',
+      IDR: '3675351.03275',
+      ILS: '846.1232415',
+      IMP: '193.01413945',
+      INR: '18345.655135',
+      IQD: '298009.02802165',
+      ISK: '34745.5495',
+      JEP: '193.01413945',
+      JMD: '36409.6696094',
+      JOD: '177.21455',
+      JPY: '26360.601825',
+      KES: '27184.562',
+      KGS: '20308.0755724',
+      KHR: '1025880.7533059',
+      KMF: '105029.03124175',
+      KNC: '274.68542227594924615',
+      KRW: '284915.23080495',
+      KWD: '76.4532063',
+      KYD: '208.2943328',
+      KZT: '107014.42658325',
+      LAK: '2310183.71158185',
+      LBP: '378370.54450325',
+      LINK: '22.894634759817007489',
+      LKR: '46090.95971405',
+      LRC: '1457.8594342373869446',
+      LRD: '48852.72175115',
+      LSL: '4122.3008749',
+      LTC: '5.2062070401999589123',
+      LTL: '806.05000775',
+      LVL: '164.03243695',
+      LYD: '341.5926678',
+      MAD: '2298.47346335',
+      MDL: '4228.5806147',
+      MGA: '982179.7557538',
+      MKD: '13087.73767885',
+      MKR: '0.43764476902003812305',
+      MMK: '322679.7621378',
+      MNT: '709349.8756452',
+      MOP: '1995.2583685',
+      MRO: '89232.15',
+      MTL: '170.9003131',
+      MUR: '9974.21650765',
+      MVR: '3849.23',
+      MWK: '188665.67006785',
+      MXN: '5298.265135',
+      MYR: '1036.517655',
+      MZN: '18229.3548997',
+      NAD: '4134.173',
+      NGN: '95481.03472305',
+      NIO: '8698.6554209',
+      NMR: '8.624556609112112958',
+      NOK: '2334.203066',
+      NPR: '29318.1806909',
+      NZD: '379.2351378',
+      OMG: '74.464123456422320125',
+      OMR: '96.23549905',
+      OXT: '1033.27821413807369045',
+      PAB: '249.95',
+      PEN: '896.6071427',
+      PGK: '874.90073485',
+      PHP: '12136.85639315',
+      PKR: '40613.9575836',
+      PLN: '971.640633',
+      PYG: '1756126.21474795',
+      QAR: '910.1304375',
+      REN: '769.6689761354887733',
+      REP: '18.2912550311013566725',
+      REPV2: '18.1582473904586151205',
+      RON: '1035.54285',
+      RSD: '24943.76025',
+      RUB: '19402.093805',
+      RWF: '244237.3512583',
+      SAR: '937.65668115',
+      SBD: '2019.805958',
+      SCR: '4576.6749819',
+      SEK: '2207.698372',
+      SGD: '339.57582125',
+      SHP: '193.01413945',
+      SLL: '2490751.74625075',
+      SOS: '145044.39506805',
+      SRD: '3537.7923',
+      SSP: '32558.487',
+      STD: '5250063.0293496',
+      SVC: '2187.04525345',
+      SZL: '4118.75383445',
+      THB: '7800.314625',
+      TJS: '2579.48624955',
+      TMT: '874.825',
+      TND: '688.2998125',
+      TOP: '579.953986',
+      TRY: '1969.70598',
+      TTD: '1696.3476626',
+      TWD: '7179.16412995',
+      TZS: '579879.84308155',
+      UAH: '7090.3476468',
+      UGX: '935325.80066935',
+      UMA: '29.276720351390922145',
+      UNI: '78.76161966283282792',
+      USD: '249.95',
+      USDC: '249.95',
+      UYU: '10724.30446005',
+      UZS: '2592145.88136715',
+      VEF: '62109486.17813795',
+      VES: '113073216.80555545',
+      VND: '5792476.0820382',
+      VUV: '28582.2184128',
+      WST: '655.5403657',
+      XAF: '139318.05656485',
+      XAG: '10.233577875',
+      XAU: '0.1313462255',
+      XCD: '675.5023725',
+      XDR: '177.0940741',
+      XLM: '2935.3219224332811736',
+      XOF: '139318.05656485',
+      XPD: '0.1065011955',
+      XPF: '25344.75028595',
+      XPT: '0.290981792',
+      XRP: '1016.6768354687817832',
+      XTZ: '114.010080507218287957',
+      YER: '62574.97275195',
+      YFI: '0.0181099566723181033515',
+      ZAR: '4130.57372',
+      ZEC: '3.88966697790227161905',
+      ZMK: '1313006.15998725',
+      ZMW: '5048.6210738',
+      ZRX: '642.804422350408735165',
+      ZWL: '80483.9'
+    }
+  }
+}
+
+const mockCoinexFeed = {
+  code: 0,
+  data: {
+    date: 1605649499848,
+    ticker: {
+      vol: '26717.39062407',
+      low: '10.4000',
+      open: '11.8000',
+      high: '19.0029',
+      last: '18.5000',
+      buy: '18.0100',
+      buy_amount: '200.00000000',
+      sell: '18.5000',
+      sell_amount: '47.89580474'
+    }
+  },
+  message: 'OK'
+}
+
+module.exports = {
+  mockCoinbaseFeed,
+  mockCoinexFeed
+}

test/v4/mocks/raw-transactions-mocks.js

@@ -0,0 +1,157 @@
+/*
+  This library contains mocking data for running unit tests.
+*/
+
+'use strict'
+
+const mockDecodeRawTransaction = {
+  txid: 'a332237d82a2543af1b0e1ae3c8cea1610c290ebcaf084a7e9894a61de0be988',
+  hash: 'a332237d82a2543af1b0e1ae3c8cea1610c290ebcaf084a7e9894a61de0be988',
+  size: 226,
+  version: 2,
+  locktime: 0,
+  vin: [
+    {
+      txid: '21cced645eab150585ed7ca7c96edebab5793cc0a3b3b286c42fd7d6d798b5b9',
+      vout: 1,
+      scriptSig: {
+        asm:
+          '3045022100a7b1b08956abb8d6f322aa709d8583c8ea492ba0585f1a6f4f9983520af74a5a0220411aee4a9a54effab617b0508c504c31681b15f9b187179b4874257badd41390[ALL|FORKID] 0360cfc66fdacb650bc4c83b4e351805181ee696b7d5ab4667c57b2786f51c413d',
+        hex:
+          '483045022100a7b1b08956abb8d6f322aa709d8583c8ea492ba0585f1a6f4f9983520af74a5a0220411aee4a9a54effab617b0508c504c31681b15f9b187179b4874257badd4139041210360cfc66fdacb650bc4c83b4e351805181ee696b7d5ab4667c57b2786f51c413d'
+      },
+      sequence: 4294967295
+    }
+  ],
+  vout: [
+    {
+      value: 0.0001,
+      n: 0,
+      scriptPubKey: {
+        asm:
+          'OP_DUP OP_HASH160 eb4b180def88e3f5625b2d8ae2c098ff7d85f664 OP_EQUALVERIFY OP_CHECKSIG',
+        hex: '76a914eb4b180def88e3f5625b2d8ae2c098ff7d85f66488ac',
+        reqSigs: 1,
+        type: 'pubkeyhash',
+        addresses: [Array]
+      }
+    },
+    {
+      value: 0.09989752,
+      n: 1,
+      scriptPubKey: {
+        asm:
+          'OP_DUP OP_HASH160 eb4b180def88e3f5625b2d8ae2c098ff7d85f664 OP_EQUALVERIFY OP_CHECKSIG',
+        hex: '76a914eb4b180def88e3f5625b2d8ae2c098ff7d85f66488ac',
+        reqSigs: 1,
+        type: 'pubkeyhash',
+        addresses: [Array]
+      }
+    }
+  ]
+}
+
+const mockDecodeScript = {
+  asm:
+    '0 0 -57 OP_NOP6 OP_LSHIFT OP_UNKNOWN OP_UNKNOWN OP_UNKNOWN c486b2b3a3c03c79b5bade6ec9a77ced850515ab5e64edcc21010000006b483045022100a7b1b08956abb8d6f322aa OP_2OVER OP_NUMEQUALVERIFY OP_OR OP_INVERT OP_UNKNOWN OP_UNKNOWN 2ba0585f1a6f4f9983520af74a5a0220411aee4a9a54effab617b0508c504c31681b15f9b187179b4874257badd4139041210360cfc66fdacb650bc4c83b4e351805181ee696b7d5ab 67c57b2786f51c413dffffffff0210270000000000001976a914eb4b180def88e3f5625b2d8ae2c098ff7d85f66488ac786e9800000000001976a914eb4b180def88e3f5625b [error]',
+  type: 'nonstandard',
+  p2sh: 'bchtest:pzy6dwfy6yf373w0dr05a6flfqksurjhwcl3awhdvm'
+}
+
+const mockRawTransactionConcise =
+  '02000000014e6b52500110b1c30315b85805fb274f0f4afceffc1589f889b27709e59e987d000000006a473044022052762770baa71c1a0b9544ad0f1ea343d32c22aa87c5f8397b6852f464c15b1e02201f4390745cb470e21e0e3c14229f39fef55ea0643a4c997f99d9f3501eae09b7412103c346eee77a77a8d3e073dacc0532ca7a5b9747bc06d88bf091cac9f4bc8bb792ffffffff02d1778f950a0000001976a91436d2f27bbd826a86db1e93618ce3de89ef33169388ac80969800000000001976a914152ea3cd65f18cb8fa9146c84ea1a97af8f051de88ac00000000'
+
+const mockRawTransactionVerbose = {
+  hex:
+    '02000000014e6b52500110b1c30315b85805fb274f0f4afceffc1589f889b27709e59e987d000000006a473044022052762770baa71c1a0b9544ad0f1ea343d32c22aa87c5f8397b6852f464c15b1e02201f4390745cb470e21e0e3c14229f39fef55ea0643a4c997f99d9f3501eae09b7412103c346eee77a77a8d3e073dacc0532ca7a5b9747bc06d88bf091cac9f4bc8bb792ffffffff02d1778f950a0000001976a91436d2f27bbd826a86db1e93618ce3de89ef33169388ac80969800000000001976a914152ea3cd65f18cb8fa9146c84ea1a97af8f051de88ac00000000',
+  txid: 'bd320377db7026a3dd5c7ec444596c0ee18fc25c4f34ee944adc03e432ce1971',
+  hash: 'bd320377db7026a3dd5c7ec444596c0ee18fc25c4f34ee944adc03e432ce1971',
+  size: 225,
+  version: 2,
+  locktime: 0,
+  vin: [
+    {
+      txid: '7d989ee50977b289f88915fceffc4a0f4f27fb0558b81503c3b1100150526b4e',
+      vout: 0,
+      scriptSig: {
+        asm:
+          '3044022052762770baa71c1a0b9544ad0f1ea343d32c22aa87c5f8397b6852f464c15b1e02201f4390745cb470e21e0e3c14229f39fef55ea0643a4c997f99d9f3501eae09b7[ALL|FORKID] 03c346eee77a77a8d3e073dacc0532ca7a5b9747bc06d88bf091cac9f4bc8bb792',
+        hex:
+          '473044022052762770baa71c1a0b9544ad0f1ea343d32c22aa87c5f8397b6852f464c15b1e02201f4390745cb470e21e0e3c14229f39fef55ea0643a4c997f99d9f3501eae09b7412103c346eee77a77a8d3e073dacc0532ca7a5b9747bc06d88bf091cac9f4bc8bb792'
+      },
+      sequence: 4294967295
+    }
+  ],
+  vout: [
+    {
+      value: 454.58880465,
+      n: 0,
+      scriptPubKey: {
+        asm:
+          'OP_DUP OP_HASH160 36d2f27bbd826a86db1e93618ce3de89ef331693 OP_EQUALVERIFY OP_CHECKSIG',
+        hex: '76a91436d2f27bbd826a86db1e93618ce3de89ef33169388ac',
+        reqSigs: 1,
+        type: 'pubkeyhash',
+        addresses: ['bchtest:qqmd9unmhkpx4pkmr6fkrr8rm6y77vckjvqe8aey35']
+      }
+    },
+    {
+      value: 0.1,
+      n: 1,
+      scriptPubKey: {
+        asm:
+          'OP_DUP OP_HASH160 152ea3cd65f18cb8fa9146c84ea1a97af8f051de OP_EQUALVERIFY OP_CHECKSIG',
+        hex: '76a914152ea3cd65f18cb8fa9146c84ea1a97af8f051de88ac',
+        reqSigs: 1,
+        type: 'pubkeyhash',
+        addresses: ['bchtest:qq2jag7dvhccew86j9rvsn4p49a03uz3mcpw3d6aca']
+      }
+    }
+  ],
+  blockhash: '000000000000026fa244de975ca89ea08008aa566564ce2e8ebb3144361b601b',
+  confirmations: 125,
+  time: 1542646373,
+  blocktime: 1542646373
+}
+
+const mockWHDecode = {
+  txid: 'f8a9857fe3b8a288b5fcafb1b0fc196731f433add6d962f77acd7c10b970ff89',
+  fee: '500',
+  sendingaddress: 'bchtest:qzjtnzcvzxx7s0na88yrg3zl28wwvfp97538sgrrmr',
+  referenceaddress: 'bchtest:qzjtnzcvzxx7s0na88yrg3zl28wwvfp97538sgrrmr',
+  ismine: false,
+  version: 0,
+  type_int: 0,
+  type: 'Simple Send',
+  propertyid: 368,
+  precision: '8',
+  amount: '10.00000000',
+  valid: true,
+  blockhash: '0000000046ba0bcef78caaa4492622176bbc563cf249ab52340a0449bc8e26f6',
+  blocktime: 1542814183,
+  positioninblock: 57,
+  block: 1269008,
+  confirmations: 2
+}
+
+const mockWHCreateInput = {
+  txid: 'f7ed9cf23dee85910f6269c9a101a75fcfd2f3c6fc81f17fad824ff7aaf99ab2',
+  vout: 1,
+  scriptPubKey: '76a914a4b98b0c118de83e7d39c834445f51dce62425f588ac',
+  amount: 0.09984138,
+  satoshis: 9984138,
+  height: 1269011,
+  confirmations: 4,
+  legacyAddress: 'mvXwPH74hW2yVTWwDwzsjGoaUAqJvWk7ZJ',
+  cashAddress: 'bchtest:qzjtnzcvzxx7s0na88yrg3zl28wwvfp97538sgrrmr',
+  value: 0.09984138
+}
+
+module.exports = {
+  mockDecodeRawTransaction,
+  mockDecodeScript,
+  mockRawTransactionConcise,
+  mockRawTransactionVerbose,
+  mockWHDecode,
+  mockWHCreateInput
+}

test/v4/mocks/slp-mocks.js

@@ -0,0 +1,636 @@
+/*
+  This library contains mocking data for running unit tests.
+*/
+
+'use strict'
+
+const mockList = {
+  t: [
+    {
+      tokenDetails: {
+        tokenIdHex:
+          'df808a41672a0a0ae6475b44f272a107bc9961b90f29dc918d71301f24fe92fb',
+        documentUri: '',
+        documentSha256: '',
+        symbol: 'NAKAMOTO',
+        name: 'NAKAMOTO',
+        decimals: 8
+      },
+      tokenStats: {
+        qty_valid_txns_since_genesis: 241,
+        qty_valid_token_utxos: 151,
+        qty_valid_token_addresses: 113,
+        qty_token_circulating_supply: '20995990',
+        qty_token_burned: '4010',
+        qty_token_minted: '21000000',
+        qty_satoshis_locked_up: 81900
+      }
+    }
+  ]
+}
+
+const mockSingleToken = {
+  t: [
+    {
+      tokenDetails: {
+        decimals: 0,
+        tokenIdHex:
+          '38e97c5d7d3585a2cbf3f9580c82ca33985f9cb0845d4dcce220cb709f9538b0',
+        timestamp: '2019-06-14 06:31:37',
+        timestamp_unix: 1560493897,
+        transactionType: 'GENESIS',
+        versionType: 1,
+        documentUri: 'ot@ot.com',
+        documentSha256Hex: null,
+        symbol: 'OT',
+        name: 'Test First SLP oasis Token',
+        batonVout: 2,
+        containsBaton: true,
+        genesisOrMintQuantity: '10000',
+        sendOutputs: null
+      },
+      tokenStats: {
+        block_created: 1308634,
+        block_last_active_send: 1308655,
+        block_last_active_mint: 1308636,
+        qty_valid_txns_since_genesis: 11,
+        qty_valid_token_utxos: 9,
+        qty_valid_token_addresses: 2,
+        qty_token_minted: '20000',
+        qty_token_burned: '0',
+        qty_token_circulating_supply: '20000',
+        qty_satoshis_locked_up: 4914,
+        minting_baton_status: 'ALIVE'
+      }
+    }
+  ]
+}
+
+const mockSingleTokenError = {
+  t: []
+}
+
+const mockSingleAddress = {
+  g: [
+    {
+      _id: 'f05faf13a29c7f5e54ab921750aafb6afaa953db863bd2cf432e918661d4132f',
+      balanceString: '0.002382',
+      slpAddress: 'simpleledger:qpujxqra3jmdlzzapwmmt7uspr7q0c9ff5me5fdrdn'
+    }
+  ],
+  t: [
+    {
+      tokenDetails: {
+        decimals: 6,
+        tokenIdHex:
+          'f05faf13a29c7f5e54ab921750aafb6afaa953db863bd2cf432e918661d4132f'
+      }
+    }
+  ]
+}
+
+const mockTx = {
+  txid: '57b3082a2bf269b3d6f40fee7fb9c664e8256a88ca5ee2697c05b9457822d446',
+  version: 2,
+  locktime: 0,
+  vin: [
+    {
+      txid: '61e71554a3dc18158f30d9e8f5c9b6641a789690b32302899f81cbea9fe3bb49',
+      vout: 2,
+      sequence: 4294967295,
+      n: 0,
+      scriptSig: {
+        hex:
+          '4730440220409e79fec552f01203f41d3d621ae3db89c720af261c8268ce5f0453de009f5d022001e7ffefeba7b0716d32ea55cb6ace267b6ee9cbcc8a017bb9c3b6acf7889418412103c87f0ec048a0771bdb60533d45cac88c6974afeb055a65edd663c2f947335585',
+        asm:
+          '30440220409e79fec552f01203f41d3d621ae3db89c720af261c8268ce5f0453de009f5d022001e7ffefeba7b0716d32ea55cb6ace267b6ee9cbcc8a017bb9c3b6acf7889418[ALL|FORKID] 03c87f0ec048a0771bdb60533d45cac88c6974afeb055a65edd663c2f947335585'
+      },
+      value: 546,
+      legacyAddress: 'mw22g57T9YA7MZQQu5eBDKj3PKTdt99oDL',
+      cashAddress: 'bchtest:qz4qnxcxwvmacgye8wlakhz0835x0w3vtvaga95c09'
+    },
+    {
+      txid: '61e71554a3dc18158f30d9e8f5c9b6641a789690b32302899f81cbea9fe3bb49',
+      vout: 1,
+      sequence: 4294967295,
+      n: 1,
+      scriptSig: {
+        hex:
+          '483045022100a743bee56c99bd103be48a78fa4c7342100815d9d2448dbe6e1d338c3a13b241022066728b5279fc22eef5cd019582ff34771e29175835fc98aa3168a1548fd78ac8412103c87f0ec048a0771bdb60533d45cac88c6974afeb055a65edd663c2f947335585',
+        asm:
+          '3045022100a743bee56c99bd103be48a78fa4c7342100815d9d2448dbe6e1d338c3a13b241022066728b5279fc22eef5cd019582ff34771e29175835fc98aa3168a1548fd78ac8[ALL|FORKID] 03c87f0ec048a0771bdb60533d45cac88c6974afeb055a65edd663c2f947335585'
+      },
+      value: 546,
+      legacyAddress: 'mw22g57T9YA7MZQQu5eBDKj3PKTdt99oDL',
+      cashAddress: 'bchtest:qz4qnxcxwvmacgye8wlakhz0835x0w3vtvaga95c09'
+    },
+    {
+      txid: '61e71554a3dc18158f30d9e8f5c9b6641a789690b32302899f81cbea9fe3bb49',
+      vout: 3,
+      sequence: 4294967295,
+      n: 2,
+      scriptSig: {
+        hex:
+          '483045022100821473902eec5f1ce7d43b1ba7f9ec453bfe8b8dfc3de3e0723c883ab109922f02206162960e80618531fab2c16aee260fddd7979bab62471c8686af7de75f8732ec412103c87f0ec048a0771bdb60533d45cac88c6974afeb055a65edd663c2f947335585',
+        asm:
+          '3045022100821473902eec5f1ce7d43b1ba7f9ec453bfe8b8dfc3de3e0723c883ab109922f02206162960e80618531fab2c16aee260fddd7979bab62471c8686af7de75f8732ec[ALL|FORKID] 03c87f0ec048a0771bdb60533d45cac88c6974afeb055a65edd663c2f947335585'
+      },
+      value: 9997521,
+      legacyAddress: 'mw22g57T9YA7MZQQu5eBDKj3PKTdt99oDL',
+      cashAddress: 'bchtest:qz4qnxcxwvmacgye8wlakhz0835x0w3vtvaga95c09'
+    }
+  ],
+  vout: [
+    {
+      value: '0.00000000',
+      n: 0,
+      scriptPubKey: {
+        hex:
+          '6a04534c500001010453454e44207ac7f4bb50b019fe0f5c81e3fc13fc0720e130282ea460768cafb49785eb2796080000000049504f80080000001c71e64280',
+        asm:
+          'OP_RETURN 5262419 1 1145980243 7ac7f4bb50b019fe0f5c81e3fc13fc0720e130282ea460768cafb49785eb2796 0000000049504f80 0000001c71e64280'
+      },
+      spentTxId: null,
+      spentIndex: null,
+      spentHeight: null
+    },
+    {
+      value: '0.00000546',
+      n: 1,
+      scriptPubKey: {
+        hex: '76a914396b8e57ad0cb58d30e2992f22047b3c20377aa688ac',
+        asm:
+          'OP_DUP OP_HASH160 396b8e57ad0cb58d30e2992f22047b3c20377aa6 OP_EQUALVERIFY OP_CHECKSIG',
+        addresses: ['mkkZf7T3fU3vHSzNPy51HBmM46ghN1gnN9'],
+        type: 'pubkeyhash'
+      },
+      spentTxId: null,
+      spentIndex: null,
+      spentHeight: null
+    },
+    {
+      value: '0.00000546',
+      n: 2,
+      scriptPubKey: {
+        hex: '76a914aa099b067337dc20993bbfdb5c4f3c6867ba2c5b88ac',
+        asm:
+          'OP_DUP OP_HASH160 aa099b067337dc20993bbfdb5c4f3c6867ba2c5b OP_EQUALVERIFY OP_CHECKSIG',
+        addresses: ['mw22g57T9YA7MZQQu5eBDKj3PKTdt99oDL'],
+        type: 'pubkeyhash'
+      },
+      spentTxId: null,
+      spentIndex: null,
+      spentHeight: null
+    },
+    {
+      value: '0.09996891',
+      n: 3,
+      scriptPubKey: {
+        hex: '76a914aa099b067337dc20993bbfdb5c4f3c6867ba2c5b88ac',
+        asm:
+          'OP_DUP OP_HASH160 aa099b067337dc20993bbfdb5c4f3c6867ba2c5b OP_EQUALVERIFY OP_CHECKSIG',
+        addresses: ['mw22g57T9YA7MZQQu5eBDKj3PKTdt99oDL'],
+        type: 'pubkeyhash'
+      },
+      spentTxId: null,
+      spentIndex: null,
+      spentHeight: null
+    }
+  ],
+  blockhash: '000000000000ce978accc64a6bb567acf0c653c202309a0f8e220149bf0c6968',
+  blockheight: 1287490,
+  confirmations: 746,
+  time: 1550855104,
+  blocktime: 1550855104,
+  valueOut: 0.09997983,
+  size: 628,
+  valueIn: 0.09998613,
+  fees: 0.0000063,
+  tokenInfo: {
+    versionType: 1,
+    transactionType: 'SEND',
+    tokenIdHex:
+      '7ac7f4bb50b019fe0f5c81e3fc13fc0720e130282ea460768cafb49785eb2796',
+    sendOutputs: ['0', '1230000000', '122170000000']
+  },
+  tokenIsValid: true
+}
+
+const mockConvert = {
+  slpAddress: 'slptest:qz35h5mfa8w2pqma2jq06lp7dnv5fxkp2shlcycvd5',
+  cashAddress: 'bchtest:qz35h5mfa8w2pqma2jq06lp7dnv5fxkp2svtllzmlf',
+  legacyAddress: 'mvQPGnzRT6gMWASZBMg7NcT3vmvsSKSQtf'
+}
+
+const mockTokenDetails = {
+  tokenIdHex:
+    'df808a41672a0a0ae6475b44f272a107bc9961b90f29dc918d71301f24fe92fb',
+  documentUri: '',
+  symbol: 'NAKAMOTO',
+  name: 'NAKAMOTO',
+  decimals: 8,
+  timestamp: '',
+  containsBaton: true,
+  versionType: 1
+}
+
+const mockTokenStats = {
+  qty_valid_txns_since_genesis: 241,
+  qty_valid_token_utxos: 151,
+  qty_valid_token_addresses: 113,
+  qty_token_circulating_supply: '20995990',
+  qty_token_burned: '4010',
+  qty_token_minted: '21000000',
+  qty_satoshis_locked_up: 81900
+}
+
+const mockBalance = {
+  _id: 'simpleledger:qp9d8mn8ypryfvea2mev0ggc3wg6plpn4suuaeuss3',
+  token_balance: '1000'
+}
+
+const mockTransactions = [
+  {
+    txid: 'a302f045be8efa1cd982833a7f187ff4fac8baac36da0c887eb2787d8b45e2af',
+    tokenDetails: {
+      valid: true,
+      detail: {
+        decimals: null,
+        tokenIdHex:
+          '495322b37d6b2eae81f045eda612b95870a0c2b6069c58f70cf8ef4e6a9fd43a',
+        timestamp: null,
+        transactionType: 'MINT',
+        versionType: 1,
+        documentUri: null,
+        documentSha256Hex: null,
+        symbol: null,
+        name: null,
+        batonVout: 2,
+        containsBaton: true,
+        genesisOrMintQuantity: {
+          $numberDecimal: '1000'
+        },
+        sendOutputs: null
+      },
+      invalidReason: null,
+      schema_version: 30
+    }
+  }
+]
+
+const mockFoobar = {
+  c: [],
+  u: []
+}
+
+const mockSingleValidTxid = {
+  c: [
+    {
+      _id: '5d965fc27f1cf2184ca2fe73',
+      tx: {
+        h: '77872738b6bddee6c0cbdb9509603de20b15d4f6b26602f629417aec2f5d5e8d'
+      },
+      slp: {
+        valid: true,
+        invalidReason: null
+      }
+    }
+  ],
+  u: []
+}
+
+const mockTwoValidTxid = {
+  c: [
+    {
+      _id: '5d965fc27f1cf2184ca2fe73',
+      tx: {
+        h: '77872738b6bddee6c0cbdb9509603de20b15d4f6b26602f629417aec2f5d5e8d'
+      },
+      slp: {
+        valid: true,
+        invalidReason: null
+      }
+    },
+    {
+      _id: '5d71e69758380a002c492a90',
+      tx: {
+        h: '552112f9e458dc7d1d8b328b0a6685e8af74a64b60b6846e7c86407f27f47e42'
+      },
+      slp: {
+        valid: true,
+        invalidReason: null
+      }
+    }
+  ],
+  u: []
+}
+
+const mockTwoRedundentTxid = {
+  c: [
+    {
+      _id: '5db99c72a391ae2afd604bde',
+      tx: {
+        h: 'd56a2b446d8149c39ca7e06163fe8097168c3604915f631bc58777d669135a56'
+      },
+      slp: {
+        valid: true,
+        invalidReason: null
+      }
+    }
+  ],
+  u: []
+}
+
+const mockPsfToken = {
+  c: [
+    {
+      _id: '5fcaf6152898f9887902986c',
+      tx: {
+        h: 'cdfed769ef7b69e09be06d2821b88598d9a5d711b8f9bd369763c78b7a578fbc'
+      },
+      slp: {
+        valid: true,
+        invalidReason: null
+      }
+    }
+  ],
+  u: []
+}
+
+const mockTxHistory = [
+  {
+    tx: {
+      h: '3a7646b3976a8745928c7192c8dde989bfa275fa6d7bce950180ab8002cf6cef'
+    },
+    in: [
+      {
+        i: 0,
+        e: {
+          h: '7bdd586ebd1e5f3dfd5295ab6e896c48b25855ab77a72c035ce1e7aacc965c2d',
+          i: 1,
+          s:
+            'RzBEAiAsu5o9EnxgZChjxKygxhGLhlfxJJbQfd4PP/vp2od3fAIgPpMqg+Sp4YpiInQZ6weJwELq8LEIrHXJpueBz7yF5gRBIQLsyL3809mRphc/+tPAcTQO5bi0kqZRFKpKIHXE3qN8Rw==',
+          a: 'simpleledger:qrrrpqmdkggpnw0czwg0jgcjd7yhu25jy5zxh2gqdq'
+        }
+      },
+      {
+        i: 1,
+        e: {
+          h: 'df49feff24dc34a10a44a0cbd7c908d964801ec7218512c84574fbce698535f0',
+          i: 3,
+          s:
+            'SDBFAiEAhW3zbKTlPrOXD2E2oEcNof6vCMPGYIg8vOVSE9c8IakCIFLg/gxydG9eL8HMAzkScGElKWJRnfhVMpMHU3evNcrZQSEDRS7F+pSC8OxSldsT4FctJLZBU7f2+FDiE05ae1xqtN0=',
+          a: 'simpleledger:qpkpeqfslejw5pptzcy25h2jxhsc9k0vts43n26up0'
+        }
+      }
+    ],
+    out: [
+      {
+        e: {
+          v: 0,
+          i: 0,
+          s:
+            'agRTTFAAAQEEU0VORCA46XxdfTWFosvz+VgMgsozmF+csIRdTcziIMtwn5U4sAgAAAAAAJiWgAgAAAAAJHfU+g=='
+        }
+      },
+      {
+        e: {
+          v: 546,
+          i: 1,
+          s: 'dqkUqo4lVohqOK6rDd7nIIkFQ6Uf41aIrA==',
+          a: 'simpleledger:qz4guf2k3p4r3t4tph0wwgyfq4p628lr2c0cvqplza'
+        }
+      },
+      {
+        e: {
+          v: 546,
+          i: 2,
+          s: 'dqkUgYSfxf90wVkERCiOMyh16iB4d92IrA==',
+          a: 'simpleledger:qzqcf879la6vzkgygs5guvegwh4zq7rhm5nu0pljjl'
+        }
+      },
+      {
+        e: {
+          v: 21849,
+          i: 3,
+          s: 'dqkUxjCDbbIQGbn4E5D5IxJviX4qkiWIrA==',
+          a: 'simpleledger:qrrrpqmdkggpnw0czwg0jgcjd7yhu25jy5zxh2gqdq'
+        }
+      }
+    ],
+    slp: {
+      detail: {
+        decimals: 8,
+        tokenIdHex:
+          '38e97c5d7d3585a2cbf3f9580c82ca33985f9cb0845d4dcce220cb709f9538b0',
+        transactionType: 'SEND',
+        versionType: 1,
+        documentUri: 'psfoundation.cash',
+        documentSha256Hex: null,
+        symbol: 'PSF',
+        name: 'Permissionless Software Foundation',
+        txnBatonVout: null,
+        txnContainsBaton: false,
+        outputs: [
+          {
+            address: 'simpleledger:qz4guf2k3p4r3t4tph0wwgyfq4p628lr2c0cvqplza',
+            amount: '0.1'
+          },
+          {
+            address: 'simpleledger:qzqcf879la6vzkgygs5guvegwh4zq7rhm5nu0pljjl',
+            amount: '6.11833082'
+          }
+        ]
+      }
+    },
+    blk: {
+      h: '000000000000000001a47bf337ca211c1e7218234d0d70117c64d6f213f5dacb',
+      i: 634833,
+      t: 1589300214
+    }
+  },
+  {
+    tx: {
+      h: '3b11b48cab1e7c8384facf482b3f6bfe659a58245ab4aa4147b42b5cb2a5fac5'
+    },
+    in: [
+      {
+        i: 0,
+        e: {
+          h: 'e4e1e1f6b502cbd42f69b919634cea3e37fc8595e6ca800e0a7d8f6dcdfb249e',
+          i: 3,
+          s:
+            'SDBFAiEAjCGRmU28x24LMTwg5XqC+fLf3zGhTYCsSWpmF8Eshq0CIAJhxAKMbwKWC4ASmjWzplpno2ch+hGNUD6HNWOdbd4SQSECeRsZo5Fl29g0A9bfJo1E/WIdowWBsLblyxWnEB7ViFE=',
+          a: 'simpleledger:qpvsg9vl9a5mlf37a7n3yce6pktdctn73qznkmw3s7'
+        }
+      },
+      {
+        i: 1,
+        e: {
+          h: '438420345dd8b7fb4ea74aaf2e3090f44899bf3c71662243946a441de6dae720',
+          i: 2,
+          s:
+            'SDBFAiEAhmLYL4QY3mvZo3/i0XG9PJAYMruw3MaGOLJ3Z4si7hwCIAaaGwRnj/cZK3L/KKFBoMtItpGRZ10GowNN//vgn6PKQSECeRsZo5Fl29g0A9bfJo1E/WIdowWBsLblyxWnEB7ViFE=',
+          a: 'simpleledger:qpvsg9vl9a5mlf37a7n3yce6pktdctn73qznkmw3s7'
+        }
+      }
+    ],
+    out: [
+      {
+        e: {
+          v: 0,
+          i: 0,
+          s:
+            'agRTTFAAAQEEU0VORCCk+1wtoaoGTiUBikP5FlBABx2emEuhkMIip/WQU6+EsggAAAAAAA9CQAgAAAAXQnHEwA=='
+        }
+      },
+      {
+        e: {
+          v: 546,
+          i: 1,
+          s: 'dqkUqo4lVohqOK6rDd7nIIkFQ6Uf41aIrA==',
+          a: 'simpleledger:qz4guf2k3p4r3t4tph0wwgyfq4p628lr2c0cvqplza'
+        }
+      },
+      {
+        e: {
+          v: 546,
+          i: 2,
+          s: 'dqkUWQQVny9pv6Y+76cSYzoNltwufoiIrA==',
+          a: 'simpleledger:qpvsg9vl9a5mlf37a7n3yce6pktdctn73qznkmw3s7'
+        }
+      },
+      {
+        e: {
+          v: 43074,
+          i: 3,
+          s: 'dqkUWQQVny9pv6Y+76cSYzoNltwufoiIrA==',
+          a: 'simpleledger:qpvsg9vl9a5mlf37a7n3yce6pktdctn73qznkmw3s7'
+        }
+      }
+    ],
+    slp: {
+      detail: {
+        decimals: 2,
+        tokenIdHex:
+          'a4fb5c2da1aa064e25018a43f9165040071d9e984ba190c222a7f59053af84b2',
+        transactionType: 'SEND',
+        versionType: 1,
+        documentUri: 'troutsblog.com',
+        documentSha256Hex: null,
+        symbol: 'TROUT',
+        name: "Trout's test token",
+        txnBatonVout: null,
+        txnContainsBaton: false,
+        outputs: [
+          {
+            address: 'simpleledger:qz4guf2k3p4r3t4tph0wwgyfq4p628lr2c0cvqplza',
+            amount: '10000'
+          },
+          {
+            address: 'simpleledger:qpvsg9vl9a5mlf37a7n3yce6pktdctn73qznkmw3s7',
+            amount: '998990000'
+          }
+        ]
+      }
+    },
+    blk: {
+      h: '000000000000000002a4ee2ed6fe8a764ffef0b2556f545ca0b3ef39ecd2b7c4',
+      i: 634832,
+      t: 1589297145
+    }
+  }
+]
+
+const mockValidateBulk = {
+  c: [
+    {
+      _id: '5fcc1ae2aff6379ca5bbb213',
+      tx: {
+        h: '336bfe2168aac4c3303508a9e8548a0d33797a83b85b76a12d845c8d6674f79d'
+      },
+      slp: {
+        valid: true,
+        invalidReason: null
+      }
+    },
+    {
+      _id: '5fc9b4db4d54eece25b52762',
+      tx: {
+        h: 'daf4d8b8045e7a90b7af81bfe2370178f687da0e545511bce1c9ae539eba5ffd'
+      },
+      slp: {
+        valid: true,
+        invalidReason: null
+      }
+    },
+    {
+      _id: '5fc989a14d54eece25af88a6',
+      tx: {
+        h: '2bf691ad3679d928fef880b8a45b93b233f8fa0d0a92cf792313dbe77b1deb74'
+      },
+      slp: {
+        valid: false,
+        invalidReason: 'Token outputs are greater than valid token inputs.'
+      }
+    },
+    {
+      _id: '5fc974d14d54eece25ad5df2',
+      tx: {
+        h: '3a4b628cbcc183ab376d44ce5252325f042268307ffa4a53443e92b6d24fb488'
+      },
+      slp: {
+        valid: true,
+        invalidReason: null
+      }
+    }
+  ],
+  u: []
+}
+
+const mockValidate3Bulk = {
+  c: [
+    {
+      _id: '5fcaf60b2898f98879029754',
+      tx: {
+        h: 'daf4d8b8045e7a90b7af81bfe2370178f687da0e545511bce1c9ae539eba5ffd'
+      },
+      slp: {
+        valid: true,
+        invalidReason: null
+      }
+    },
+    {
+      _id: '5fcaf5382898f988790275d0',
+      tx: {
+        h: '2bf691ad3679d928fef880b8a45b93b233f8fa0d0a92cf792313dbe77b1deb74'
+      },
+      slp: {
+        valid: false,
+        invalidReason: 'Token outputs are greater than valid token inputs.'
+      }
+    }
+  ],
+  u: []
+}
+
+module.exports = {
+  mockList,
+  mockSingleToken,
+  mockConvert,
+  mockTokenDetails,
+  mockTokenStats,
+  mockTx,
+  mockBalance,
+  mockTransactions,
+  mockSingleTokenError,
+  mockSingleAddress,
+  mockFoobar,
+  mockSingleValidTxid,
+  mockTwoValidTxid,
+  mockTwoRedundentTxid,
+  mockTxHistory,
+  mockPsfToken,
+  mockValidateBulk,
+  mockValidate3Bulk
+}

test/v4/mocks/slpjs-mocks.js

@@ -0,0 +1,71 @@
+/*
+  Mocks used for unit tests that interact with slpjs.
+*/
+
+'use strict'
+
+// const sinon = require('sinon')
+// const proxyquire = require('proxyquire')
+const BigNumber = require('bignumber.js')
+const slpMocks = require('./slp-mocks')
+
+// Mock the BitboxNetwork class.
+class BitboxNetwork {
+  // constructor () {}
+
+  async getAllSlpBalancesAndUtxos (address) {
+    return {
+      satoshis_available_bch: 9996891,
+      satoshis_in_slp_baton: 546,
+      satoshis_in_slp_token: 546,
+      satoshis_in_invalid_token_dag: 0,
+      satoshis_in_invalid_baton_dag: 0,
+      slpTokenBalances: {
+        '7ac7f4bb50b019fe0f5c81e3fc13fc0720e130282ea460768cafb49785eb2796': new BigNumber(
+          123400000000
+        )
+      },
+      slpTokenUtxos: {
+        '7ac7f4bb50b019fe0f5c81e3fc13fc0720e130282ea460768cafb49785eb2796': []
+      },
+      slpBatonUtxos: {
+        '7ac7f4bb50b019fe0f5c81e3fc13fc0720e130282ea460768cafb49785eb2796': []
+      },
+      nonSlpUtxos: [{}],
+      invalidTokenUtxos: [],
+      invalidBatonUtxos: []
+    }
+  }
+
+  async getTokenInformation (txid) {
+    BigNumber.set({ DECIMAL_PLACES: 8, ROUNDING_MODE: 4 })
+
+    const obj = {
+      versionType: 1,
+      transactionType: 0,
+      symbol: 'SLPSDK',
+      name: 'SLP SDK example using BITBOX',
+      documentUri: 'developer.bitcoin.com',
+      documentSha256: null,
+      decimals: 8,
+      batonVout: 2,
+      containsBaton: true,
+      genesisOrMintQuantity: new BigNumber(123400000000)
+    }
+
+    return obj
+  }
+
+  async getTransactionDetails (txid) {
+    return slpMocks.mockTx
+  }
+}
+
+// Mock the slpjs library.
+const slpjs = {
+  BitboxNetwork,
+  slp: {},
+  validator: {}
+}
+
+module.exports = slpjs

test/v4/mocks/transaction-mocks.js

@@ -0,0 +1,74 @@
+/*
+  This library contains mocking data for running unit tests on the address route.
+*/
+
+'use strict'
+
+/*
+const mockDetails = {
+  txid: "6f235bd3a689f03c11969cd649ccad592462ca958bc519a30194e7a67b349a40",
+  version: 2,
+  locktime: 0,
+  vin: [Array],
+  vout: [Array],
+  blockhash: "00000000e7232ff12462dedf9c11985f5b54202515277c337ccc59812758f28b",
+  blockheight: 1270188,
+  confirmations: 2,
+  time: 1543436253,
+  blocktime: 1543436253,
+  valueOut: 450.78867333,
+  size: 226,
+  valueIn: 450.78867559,
+  fees: 0.00000226
+}
+*/
+
+const mockDetails = {
+  txid: '6f235bd3a689f03c11969cd649ccad592462ca958bc519a30194e7a67b349a40',
+  version: 2,
+  locktime: 0,
+  vin: [
+    {
+      txid: '273d616d1c48f4b075c497f36ffdc79da5c8d6ed75485808b3599aac504f8525',
+      vout: 0,
+      sequence: 4294967295,
+      n: 0,
+      scriptSig: [{}],
+      addr: 'bchtest:qqmd9unmhkpx4pkmr6fkrr8rm6y77vckjvqe8aey35',
+      valueSat: 45078867559,
+      value: 450.78867559,
+      doubleSpentTxID: null
+    }
+  ],
+  vout: [
+    {
+      value: '450.68867333',
+      n: 0,
+      scriptPubKey: [{}],
+      spentTxId: null,
+      spentIndex: null,
+      spentHeight: null
+    },
+    {
+      value: '0.10000000',
+      n: 1,
+      scriptPubKey: [{}],
+      spentTxId: null,
+      spentIndex: null,
+      spentHeight: null
+    }
+  ],
+  blockhash: '00000000e7232ff12462dedf9c11985f5b54202515277c337ccc59812758f28b',
+  blockheight: 1270188,
+  confirmations: 3,
+  time: 1543436253,
+  blocktime: 1543436253,
+  valueOut: 450.78867333,
+  size: 226,
+  valueIn: 450.78867559,
+  fees: 0.00000226
+}
+
+module.exports = {
+  mockDetails
+}

test/v4/mocks/util-mocks.js

@@ -0,0 +1,130 @@
+/*
+  This library contains mocking data for running unit tests on the address route.
+*/
+
+'use strict'
+
+const mockAddress = {
+  isvalid: true,
+  address: 'bchtest:qqqk4y6lsl5da64sg5qc3xezmplyu5kmpyz2ysaa5y',
+  scriptPubKey: '76a914016a935f87e8deeab04501889b22d87e4e52db0988ac',
+  ismine: false,
+  iswatchonly: false,
+  isscript: false
+}
+
+const mockBalance = {
+  page: 1,
+  totalPages: 1,
+  itemsOnPage: 1000,
+  address: 'bitcoincash:qzp7gdl52edm24xlpkyqnza9rv43u3mdxyc77j3u6k',
+  balance: '2546',
+  totalReceived: '2546',
+  totalSent: '0',
+  unconfirmedBalance: '0',
+  unconfirmedTxs: 0,
+  txs: 2,
+  txids: [
+    'e190d13b88578132608ab912a4d2be3e55aa2792d6042d481ae21d700639de56',
+    '44e1f48c4093fc61db1a8fa206aa402fc34e482b3f788cb38c123ca0e1a35db6'
+  ]
+}
+
+const mockUtxos = [
+  {
+    txid: 'e190d13b88578132608ab912a4d2be3e55aa2792d6042d481ae21d700639de56',
+    vout: 0,
+    value: '2000',
+    height: 605873,
+    confirmations: 298,
+    satoshis: 2000
+  },
+  {
+    txid: '44e1f48c4093fc61db1a8fa206aa402fc34e482b3f788cb38c123ca0e1a35db6',
+    vout: 1,
+    value: '546',
+    height: 605873,
+    confirmations: 298,
+    satoshis: 546
+  }
+]
+
+const mockThreeUtxos = [
+  {
+    txid: 'e190d13b88578132608ab912a4d2be3e55aa2792d6042d481ae21d700639de56',
+    vout: 0,
+    value: '2000',
+    height: 605873,
+    confirmations: 298,
+    satoshis: 2000
+  },
+  {
+    txid: '44e1f48c4093fc61db1a8fa206aa402fc34e482b3f788cb38c123ca0e1a35db6',
+    vout: 1,
+    value: '546',
+    height: 605873,
+    confirmations: 298,
+    satoshis: 546
+  },
+  {
+    txid: '44e1f48c4093fc61db1a8fa206aa402fc34e482b3f788cb38c123ca0e1a35db6',
+    vout: 1,
+    value: '546',
+    height: 605873,
+    confirmations: 298,
+    satoshis: 546
+  }
+]
+
+const mockIsTokenUtxos = [
+  false,
+  {
+    txid: '44e1f48c4093fc61db1a8fa206aa402fc34e482b3f788cb38c123ca0e1a35db6',
+    vout: 1,
+    value: '546',
+    height: 605873,
+    confirmations: 298,
+    satoshis: 546,
+    utxoType: 'token',
+    transactionType: 'send',
+    tokenId: '497291b8a1dfe69c8daea50677a3d31a5ef0e9484d8bebb610dac64bbc202fb7',
+    tokenTicker: 'TOK-CH',
+    tokenName: 'TokyoCash',
+    tokenDocumentUrl: '',
+    tokenDocumentHash: '',
+    decimals: 8,
+    tokenQty: 2
+  }
+]
+
+const tapUtxo = {
+  txid: '2e030df12390186baf817fa2760540b886511e04bc520e88f6b4c2124cc2a7d4',
+  vout: 1,
+  value: '546',
+  height: 606564,
+  confirmations: 3,
+  satoshis: 546,
+  utxoType: 'token',
+  transactionType: 'send',
+  tokenId: 'dd84ca78db4d617221b58eabc6667af8fe2f7eadbfcc213d35be9f1b419beb8d',
+  tokenTicker: 'TAP',
+  tokenName: 'Thoughts and Prayers',
+  tokenDocumentUrl: '',
+  tokenDocumentHash: '',
+  decimals: 0,
+  tokenQty: 1
+}
+
+const tokensOnly = [mockIsTokenUtxos[1], tapUtxo]
+
+const multipleTokens = [false, mockIsTokenUtxos[1], tapUtxo]
+
+module.exports = {
+  mockAddress,
+  mockBalance,
+  mockUtxos,
+  mockThreeUtxos,
+  mockIsTokenUtxos,
+  tokensOnly,
+  multipleTokens
+}

test/v4/price.js

@@ -0,0 +1,280 @@
+/*
+  TESTS FOR THE PRICE.JS LIBRARY
+
+  This test file uses the environment variable TEST to switch between unit
+  and integration tests. By default, TEST is set to 'unit'. Set this variable
+  to 'integration' to run the tests against BCH mainnet.
+
+*/
+
+'use strict'
+
+const chai = require('chai')
+const assert = chai.assert
+const sinon = require('sinon')
+
+const Price = require('../../src/routes/v4/price')
+let uut
+
+// Mocking data.
+const { mockReq, mockRes } = require('./mocks/express-mocks')
+const mockData = require('./mocks/price-mock')
+
+// Used for debugging.
+const util = require('util')
+util.inspect.defaultOptions = { depth: 1 }
+
+describe('#PriceRouter', () => {
+  let req, res
+  let sandbox
+
+  before(() => {
+    // Set default environment variables for unit tests.
+    if (!process.env.TEST) process.env.TEST = 'unit'
+  })
+
+  // Setup the mocks before each test.
+  beforeEach(() => {
+    // Mock the req and res objects used by Express routes.
+    req = mockReq
+    res = mockRes
+
+    // Explicitly reset the parmas and body.
+    req.params = {}
+    req.body = {}
+    req.query = {}
+
+    sandbox = sinon.createSandbox()
+
+    uut = new Price()
+  })
+
+  afterEach(() => {
+    // Restore Sandbox
+    sandbox.restore()
+  })
+
+  after(() => {})
+
+  describe('#root', async () => {
+    // root route handler.
+    // const root = controlRoute.testableComponents.root
+
+    it('should respond to GET for base route', async () => {
+      const result = uut.root(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.equal(result.status, 'price', 'Returns static string')
+    })
+  })
+
+  describe('#getUSD', () => {
+    // const getNetworkInfo = controlRoute.testableComponents.getNetworkInfo
+
+    it('should throw 500 when network issues', async () => {
+      uut.priceUrl = 'http://fakeurl/api/'
+
+      await uut.getUSD(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.isAbove(
+        res.statusCode,
+        499,
+        'HTTP status code 500 or greater expected.'
+      )
+      // console.log(res)
+      assert.include(
+        res.output.error,
+        'Network error: Could not communicate with full node or other external service'
+      )
+    })
+
+    it('returns proper error when downstream service stalls', async () => {
+      // Mock the timeout error.
+      sandbox.stub(uut.axios, 'request').throws({ code: 'ECONNABORTED' })
+
+      const result = await uut.getUSD(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.isAbove(res.statusCode, 499, 'HTTP status code 503 expected.')
+      assert.include(
+        result.error,
+        'Could not communicate with full node',
+        'Error message expected'
+      )
+    })
+
+    it('returns proper error when downstream service is down', async () => {
+      // Mock the timeout error.
+      sandbox.stub(uut.axios, 'request').throws({ code: 'ECONNREFUSED' })
+
+      const result = await uut.getUSD(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.isAbove(res.statusCode, 499, 'HTTP status code 503 expected.')
+      assert.include(
+        result.error,
+        'Could not communicate with full node',
+        'Error message expected'
+      )
+    })
+
+    it('should get the USD price of BCH', async () => {
+      // Mock the RPC call for unit tests.
+      if (process.env.TEST === 'unit') {
+        sandbox
+          .stub(uut.axios, 'request')
+          .resolves({ data: mockData.mockCoinbaseFeed })
+      }
+
+      const result = await uut.getUSD(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.isNumber(result.usd)
+    })
+  })
+
+  describe('#getBCHRate', () => {
+    it('should throw 500 when network issues', async () => {
+      uut.priceUrl = 'http://fakeurl/api/'
+
+      await uut.getBCHRate(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.isAbove(
+        res.statusCode,
+        499,
+        'HTTP status code 500 or greater expected.'
+      )
+      // console.log(res)
+      assert.include(
+        res.output.error,
+        'Network error: Could not communicate with full node or other external service'
+      )
+    })
+
+    it('returns proper error when downstream service stalls', async () => {
+      // Mock the timeout error.
+      sandbox.stub(uut.axios, 'request').throws({ code: 'ECONNABORTED' })
+
+      const result = await uut.getBCHRate(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.isAbove(res.statusCode, 499, 'HTTP status code 503 expected.')
+      assert.include(
+        result.error,
+        'Could not communicate with full node',
+        'Error message expected'
+      )
+    })
+
+    it('returns proper error when downstream service is down', async () => {
+      // Mock the timeout error.
+      sandbox.stub(uut.axios, 'request').throws({ code: 'ECONNREFUSED' })
+
+      const result = await uut.getBCHRate(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.isAbove(res.statusCode, 499, 'HTTP status code 503 expected.')
+      assert.include(
+        result.error,
+        'Could not communicate with full node',
+        'Error message expected'
+      )
+    })
+
+    it('should get several rates for BCH', async () => {
+      // Mock the RPC call for unit tests.
+      if (process.env.TEST === 'unit') {
+        sandbox
+          .stub(uut.axios, 'request')
+          .resolves({ data: mockData.mockCoinbaseFeed })
+      }
+
+      const result = await uut.getBCHRate(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      // assert.isNumber(result)
+      assert.property(result, 'USD')
+      assert.property(result, 'CAD')
+    })
+  })
+
+  describe('#errorHandler', () => {
+    it('should handle unexpected errors', () => {
+      sandbox.stub(uut.routeUtils, 'decodeError').returns({ msg: false })
+
+      const result = uut.errorHandler(new Error('test error'), res)
+      // console.log('result: ', result)
+
+      assert.isAbove(res.statusCode, 499, 'HTTP status code 503 expected.')
+      assert.property(result, 'error')
+    })
+  })
+
+  describe('#getBCHAUSD', () => {
+    // const getNetworkInfo = controlRoute.testableComponents.getNetworkInfo
+
+    it('should throw 500 when network issues', async () => {
+      uut.coinexPriceUrl = 'http://fakeurl/api/'
+
+      await uut.getBCHAUSD(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.isAbove(
+        res.statusCode,
+        499,
+        'HTTP status code 500 or greater expected.'
+      )
+      // console.log(res)
+      assert.include(
+        res.output.error,
+        'Network error: Could not communicate with full node or other external service'
+      )
+    })
+
+    it('returns proper error when downstream service stalls', async () => {
+      // Mock the timeout error.
+      sandbox.stub(uut.axios, 'request').throws({ code: 'ECONNABORTED' })
+
+      const result = await uut.getBCHAUSD(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.isAbove(res.statusCode, 499, 'HTTP status code 503 expected.')
+      assert.include(
+        result.error,
+        'Could not communicate with full node',
+        'Error message expected'
+      )
+    })
+
+    it('returns proper error when downstream service is down', async () => {
+      // Mock the timeout error.
+      sandbox.stub(uut.axios, 'request').throws({ code: 'ECONNREFUSED' })
+
+      const result = await uut.getBCHAUSD(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.isAbove(res.statusCode, 499, 'HTTP status code 503 expected.')
+      assert.include(
+        result.error,
+        'Could not communicate with full node',
+        'Error message expected'
+      )
+    })
+
+    it('should get the USD price of BCH', async () => {
+      // Mock the RPC call for unit tests.
+      if (process.env.TEST === 'unit') {
+        sandbox
+          .stub(uut.axios, 'request')
+          .resolves({ data: mockData.mockCoinexFeed })
+      }
+
+      const result = await uut.getBCHAUSD(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.isNumber(result.usd)
+    })
+  })
+})

test/v4/rate-limits.js

@@ -0,0 +1,460 @@
+'use strict'
+
+const chai = require('chai')
+const assert = chai.assert
+// const nock = require('nock') // HTTP mocking
+const sinon = require('sinon')
+
+// Used for debugging.
+const util = require('util')
+util.inspect.defaultOptions = { depth: 1 }
+
+// Mocking data.
+const { mockReq, mockRes, mockNext } = require('./mocks/express-mocks')
+
+// Libraries under test
+const RateLimits = require('../../src/middleware/route-ratelimit')
+let rateLimits = new RateLimits()
+
+// const controlRoute = require('../../src/routes/v4/full-node/control')
+const jwtAuth = require('../../src/middleware/jwt-auth')
+
+let req, res, next
+// let originalEnvVars // Used during transition from integration to unit tests.
+
+// JWT token used in tests.
+const jwt = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjVkYWRlM2Y1NzM5ZTZjMGZmMDM0YjlhMSIsImlhdCI6MTU3MTY3NzQ1MCwiZXhwIjoxNTc0MjY5NDUwfQ.SSz7F7ETyBB3eoNG2VKCzPOhddtB-vrtmEoj7PxicrQ'
+
+describe('#route-ratelimits & jwt-auth', () => {
+  let sandbox
+
+  before(async () => {
+    // Save existing environment variables.
+    // originalEnvVars = {
+    //   BITCOINCOM_BASEURL: process.env.BITCOINCOM_BASEURL,
+    //   RPC_BASEURL: process.env.RPC_BASEURL,
+    //   RPC_USERNAME: process.env.RPC_USERNAME,
+    //   RPC_PASSWORD: process.env.RPC_PASSWORD
+    // }
+
+    if (!process.env.JWT_AUTH_SERVER) { process.env.JWT_AUTH_SERVER = 'http://fakeurl.com/' }
+
+    // Wipe the Redis DB, which prevents false negatives when running integration
+    // tests back-to-back.
+    await rateLimits.wipeRedis()
+  })
+
+  // Setup the mocks before each test.
+  beforeEach(() => {
+    // Mock the req and res objects used by Express routes.
+    req = Object.assign({}, mockReq)
+    res = Object.assign({}, mockRes)
+    next = mockNext
+
+    // Explicitly reset the parmas and body.
+    req.params = {}
+    req.body = {}
+    req.query = {}
+    req.locals = {}
+
+    sandbox = sinon.createSandbox()
+  })
+
+  afterEach(() => {
+    sandbox.restore()
+  })
+
+  after(() => {
+    rateLimits.closeRedis()
+  })
+
+  describe('#jwt-auth.js', () => {
+    describe('#getTokenFromHeaders', () => {
+      it('should populate the req.locals object correctly', () => {
+        // Initialize req.locals
+        req.locals = {
+          proLimit: false,
+          apiLevel: 0
+        }
+
+        const header = `Token ${jwt}`
+        req.headers.authorization = header
+
+        jwtAuth.getTokenFromHeaders(req, res, next)
+
+        // console.log(`req.locals: ${JSON.stringify(req.locals, null, 2)}`)
+
+        assert.property(req.locals, 'proLimit')
+        assert.property(req.locals, 'apiLevel')
+        assert.property(req.locals, 'jwtToken')
+        assert.equal(req.locals.jwtToken, jwt)
+      })
+    })
+  })
+
+  describe('#getResource', () => {
+    it('should decode a blockchain request', () => {
+      const url =
+        '/blockchain/getTxOut/62a3ea958a463a372bc0caf2c374a7f60be9c624be63a0db8db78f05809df6d8/0?include_mempool=true'
+
+      const result = rateLimits.getResource(url)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.equal(result, 'blockchain')
+    })
+  })
+
+  describe('#calcPoints', () => {
+    it('should return 50 points for anonymous user', () => {
+      const result = rateLimits.calcPoints()
+      // console.log(`result: ${result}`)
+
+      assert.equal(result, 50)
+    })
+
+    it('should return 50 points for free tier requesting full node access', () => {
+      const jwtInfo = {
+        apiLevel: 10,
+        resource: 'blockchain',
+        id: '5e3a0415eb29a962da2708b4'
+      }
+
+      const result = rateLimits.calcPoints(jwtInfo)
+      assert.equal(result, 50)
+    })
+
+    it('should return 50 points for free tier requesting indexer access', () => {
+      const jwtInfo = {
+        apiLevel: 10,
+        resource: 'blockbook',
+        id: '5e3a0415eb29a962da2708b4'
+      }
+
+      const result = rateLimits.calcPoints(jwtInfo)
+      assert.equal(result, 50)
+    })
+
+    it('should return 50 points for free tier requesting SLPDB access', () => {
+      const jwtInfo = {
+        apiLevel: 10,
+        resource: 'slp',
+        id: '5e3a0415eb29a962da2708b4'
+      }
+
+      const result = rateLimits.calcPoints(jwtInfo)
+      assert.equal(result, 50)
+    })
+
+    it('should return 10 points for full node tier requesting full node access', () => {
+      const jwtInfo = {
+        apiLevel: 20,
+        resource: 'blockchain',
+        id: '5e3a0415eb29a962da2708b4'
+      }
+
+      const result = rateLimits.calcPoints(jwtInfo)
+      assert.equal(result, 10)
+    })
+
+    it('should return 50 points for full-node tier requesting indexer access', () => {
+      const jwtInfo = {
+        apiLevel: 20,
+        resource: 'blockbook',
+        id: '5e3a0415eb29a962da2708b4'
+      }
+
+      const result = rateLimits.calcPoints(jwtInfo)
+      assert.equal(result, 50)
+    })
+
+    it('should return 50 points for full node tier requesting SLPDB access', () => {
+      const jwtInfo = {
+        apiLevel: 20,
+        resource: 'slp',
+        id: '5e3a0415eb29a962da2708b4'
+      }
+
+      const result = rateLimits.calcPoints(jwtInfo)
+      assert.equal(result, 50)
+    })
+
+    it('should return 10 point for indexer tier requesting full node access', () => {
+      const jwtInfo = {
+        apiLevel: 30,
+        resource: 'blockchain',
+        id: '5e3a0415eb29a962da2708b4'
+      }
+
+      const result = rateLimits.calcPoints(jwtInfo)
+      assert.equal(result, 10)
+    })
+
+    it('should return 10 points for indexer tier requesting indexer access', () => {
+      const jwtInfo = {
+        apiLevel: 30,
+        resource: 'blockbook',
+        id: '5e3a0415eb29a962da2708b4'
+      }
+
+      const result = rateLimits.calcPoints(jwtInfo)
+      assert.equal(result, 10)
+    })
+
+    it('should return 50 points for indexer tier requesting SLPDB access', () => {
+      const jwtInfo = {
+        apiLevel: 30,
+        resource: 'slp',
+        id: '5e3a0415eb29a962da2708b4'
+      }
+
+      const result = rateLimits.calcPoints(jwtInfo)
+      assert.equal(result, 50)
+    })
+
+    it('should return 10 point for SLP tier requesting full node access', () => {
+      const jwtInfo = {
+        apiLevel: 40,
+        resource: 'blockchain',
+        id: '5e3a0415eb29a962da2708b4'
+      }
+
+      const result = rateLimits.calcPoints(jwtInfo)
+      assert.equal(result, 10)
+    })
+
+    it('should return 10 points for SLP tier requesting indexer access', () => {
+      const jwtInfo = {
+        apiLevel: 40,
+        resource: 'blockbook',
+        id: '5e3a0415eb29a962da2708b4'
+      }
+
+      const result = rateLimits.calcPoints(jwtInfo)
+      assert.equal(result, 10)
+    })
+
+    it('should return 10 points for SLP tier requesting SLPDB access', () => {
+      const jwtInfo = {
+        apiLevel: 40,
+        resource: 'slp',
+        id: '5e3a0415eb29a962da2708b4'
+      }
+
+      const result = rateLimits.calcPoints(jwtInfo)
+      assert.equal(result, 10)
+    })
+  })
+
+  describe('#rateLimitByResource', () => {
+    // NOTE: this test will fail if you run multiple integration tests in a
+    // short period. Because it talks to the Redis DB.
+    it('should pass through rate-limit middleware', async () => {
+      req.baseUrl = '/v4'
+      req.path = '/control/getNetworkInfo'
+      req.url = req.path
+      req.method = 'GET'
+
+      // Call the route twice to trigger the rate handling.
+      await rateLimits.rateLimitByResource(req, res, next)
+      await rateLimits.rateLimitByResource(req, res, next)
+
+      // next() will be called if rate-limit is not triggered
+      assert.equal(next.called, true)
+    })
+
+    it('should trigger rate-limit handler if rate limits exceeds 5 request per minute', async () => {
+      req.baseUrl = '/v4'
+      req.path = '/control/getNetworkInfo'
+      req.url = req.path
+      req.method = 'GET'
+
+      for (let i = 0; i < 5; i++) {
+        next.reset() // reset the stubbed next() function.
+
+        await rateLimits.rateLimitByResource(req, res, next)
+        // console.log(`next() called: ${next.called}`)
+      }
+
+      // Note: next() will be called unless the rate-limit kicks in.
+      assert.equal(
+        next.called,
+        false,
+        'next should not be called if rate limit was triggered.'
+      )
+    })
+
+    it('should NOT trigger rate-limit for free-tier at 5 RPM', async () => {
+      // Create a new instance of the rate limit so we start with zeroed tracking.
+      rateLimits = new RateLimits()
+
+      req.baseUrl = '/v4'
+      req.path = '/control/getNetworkInfo'
+      req.url = req.path
+      req.method = 'GET'
+
+      req.locals.jwtToken = 'some-token'
+
+      const jwtInfo = {
+        apiLevel: 10,
+        id: '5e3a0415eb29a962da2708b1'
+      }
+
+      // Mock the call to the jwt library.
+      sandbox.stub(rateLimits.jwt, 'verify').returns(jwtInfo)
+
+      for (let i = 0; i < 5; i++) {
+        next.reset() // reset the stubbed next() function.
+
+        await rateLimits.rateLimitByResource(req, res, next)
+        // console.log(`next() called: ${next.called}`)
+      }
+
+      // console.log(`req.locals after test: ${util.inspect(req.locals)}`)
+
+      // Note: next() will be called unless the rate-limit kicks in.
+      assert.equal(
+        next.called,
+        true,
+        'next should be called if rate limit was not triggered.'
+      )
+    })
+
+    it('should trigger rate-limit for free tier after 20 RPM', async () => {
+      // Create a new instance of the rate limit so we start with zeroed tracking.
+      rateLimits = new RateLimits()
+
+      req.baseUrl = '/v4'
+      req.path = '/control/getNetworkInfo'
+      req.url = req.path
+      req.method = 'GET'
+
+      req.locals.jwtToken = 'some-token'
+
+      const jwtInfo = {
+        apiLevel: 10,
+        id: '5e3a0415eb29a962da2708b2'
+      }
+
+      // Mock the call to the jwt library.
+      sandbox.stub(rateLimits.jwt, 'verify').returns(jwtInfo)
+
+      for (let i = 0; i < 22; i++) {
+        next.reset() // reset the stubbed next() function.
+
+        await rateLimits.rateLimitByResource(req, res, next)
+        // console.log(`next() called: ${next.called}`)
+      }
+
+      // Note: next() will be called unless the rate-limit kicks in.
+      assert.equal(
+        next.called,
+        false,
+        'next should not be called if rate limit was triggered.'
+      )
+    })
+
+    it('should NOT trigger rate-limit handler for indexer-tier at 25 RPM', async () => {
+      // Create a new instance of the rate limit so we start with zeroed tracking.
+      rateLimits = new RateLimits()
+
+      req.baseUrl = '/v4'
+      req.path = '/control/getNetworkInfo'
+      req.url = req.path
+      req.method = 'GET'
+
+      req.locals.jwtToken = 'some-token'
+
+      const jwtInfo = {
+        apiLevel: 20,
+        id: '5e3a0415eb29a962da2708b3'
+      }
+
+      // Mock the call to the jwt library.
+      sandbox.stub(rateLimits.jwt, 'verify').returns(jwtInfo)
+
+      for (let i = 0; i < 25; i++) {
+        next.reset() // reset the stubbed next() function.
+
+        await rateLimits.rateLimitByResource(req, res, next)
+        // console.log(`next() called: ${next.called}`)
+      }
+
+      // console.log(`req.locals after test: ${util.inspect(req.locals)}`)
+
+      // Note: next() will be called unless the rate-limit kicks in.
+      assert.equal(
+        next.called,
+        true,
+        'next should be called if rate limit was not triggered.'
+      )
+    })
+
+    it('should still rate-limit at a higher RPM for pro-tier', async () => {
+      // Create a new instance of the rate limit so we start with zeroed tracking.
+      rateLimits = new RateLimits()
+
+      req.baseUrl = '/v4'
+      req.path = '/control/getNetworkInfo'
+      req.url = req.path
+      req.method = 'GET'
+
+      req.locals.jwtToken = 'some-token'
+
+      const jwtInfo = {
+        apiLevel: 20,
+        id: '5e3a0415eb29a962da2708b5'
+      }
+
+      // Mock the call to the jwt library.
+      sandbox.stub(rateLimits.jwt, 'verify').returns(jwtInfo)
+
+      for (let i = 0; i < 150; i++) {
+        next.reset() // reset the stubbed next() function.
+
+        await rateLimits.rateLimitByResource(req, res, next)
+        // console.log(`next() called: ${next.called}`)
+      }
+
+      // console.log(`req.locals after test: ${util.inspect(req.locals)}`)
+
+      // Note: next() will be called unless the rate-limit kicks in.
+      assert.equal(
+        next.called,
+        false,
+        'next should NOT be called if rate limit was triggered.'
+      )
+    })
+
+    it('should handle misconfigured token secret', async () => {
+      // Create a new instance of the rate limit so we start with zeroed tracking.
+      rateLimits = new RateLimits()
+
+      req.baseUrl = '/v4'
+      req.path = '/control/getNetworkInfo'
+      req.url = req.path
+      req.method = 'GET'
+
+      req.locals.jwtToken = 'some-token'
+
+      next.reset() // reset the stubbed next() function.
+
+      await rateLimits.rateLimitByResource(req, res, next)
+
+      // Issues with token secret should treat incoming requests as anonymous
+      // calls with 30 points or 3 RPM.
+      assert.equal(res.locals.pointsToConsume, 50)
+    })
+  })
+})
+
+// Generates a Basic authorization header.
+// function generateAuthHeader (pass) {
+//   // https://en.wikipedia.org/wiki/Basic_access_authentication
+//   const username = 'BITBOX'
+//   const combined = `${username}:${pass}`
+//
+//   var base64Credential = Buffer.from(combined).toString('base64')
+//   var readyCredential = `Basic ${base64Credential}`
+//
+//   return readyCredential
+// }

test/v4/util.js

@@ -0,0 +1,519 @@
+/*
+  TESTS FOR THE UTIL.TS LIBRARY
+
+  This test file uses the environment variable TEST to switch between unit
+  and integration tests. By default, TEST is set to 'unit'. Set this variable
+  to 'integration' to run the tests against BCH mainnet.
+*/
+
+'use strict'
+
+const chai = require('chai')
+const assert = chai.assert
+const utilRoute = require('../../src/routes/v4/util')
+const nock = require('nock') // HTTP mocking
+const sinon = require('sinon')
+
+let originalEnvVars // Used during transition from integration to unit tests.
+
+// Mocking data.
+const { mockReq, mockRes } = require('./mocks/express-mocks')
+const mockData = require('./mocks/util-mocks')
+
+const util = require('util')
+util.inspect.defaultOptions = { depth: 1 }
+
+// const UtilRoute = utilRoute.UtilRoute
+const utilRouteInst = new utilRoute.UtilRoute()
+
+describe('#Util', () => {
+  let req, res
+  let sandbox
+
+  before(() => {
+    // Save existing environment variables.
+    originalEnvVars = {
+      BITCOINCOM_BASEURL: process.env.BITCOINCOM_BASEURL,
+      RPC_BASEURL: process.env.RPC_BASEURL,
+      RPC_USERNAME: process.env.RPC_USERNAME,
+      RPC_PASSWORD: process.env.RPC_PASSWORD
+    }
+
+    // Set default environment variables for unit tests.
+    if (!process.env.TEST) process.env.TEST = 'unit'
+    if (process.env.TEST === 'unit') {
+      process.env.BITCOINCOM_BASEURL = 'http://fakeurl/api/'
+      process.env.RPC_BASEURL = 'http://fakeurl/api'
+      process.env.RPC_USERNAME = 'fakeusername'
+      process.env.RPC_PASSWORD = 'fakepassword'
+    }
+  })
+
+  // Setup the mocks before each test.
+  beforeEach(() => {
+    // Mock the req and res objects used by Express routes.
+    req = mockReq
+    res = mockRes
+
+    // Explicitly reset the parmas and body.
+    req.params = {}
+    req.body = {}
+    req.query = {}
+
+    // Activate nock if it's inactive.
+    if (!nock.isActive()) nock.activate()
+
+    sandbox = sinon.createSandbox()
+  })
+
+  afterEach(() => {
+    // Clean up HTTP mocks.
+    nock.cleanAll() // clear interceptor list.
+    nock.restore()
+
+    sandbox.restore()
+  })
+
+  after(() => {
+    // Restore any pre-existing environment variables.
+    process.env.BITCOINCOM_BASEURL = originalEnvVars.BITCOINCOM_BASEURL
+    process.env.RPC_BASEURL = originalEnvVars.RPC_BASEURL
+    process.env.RPC_USERNAME = originalEnvVars.RPC_USERNAME
+    process.env.RPC_PASSWORD = originalEnvVars.RPC_PASSWORD
+  })
+
+  describe('#root', async () => {
+    // root route handler.
+    const root = utilRouteInst.root
+
+    it('should respond to GET for base route', async () => {
+      const result = root(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.equal(result.status, 'util', 'Returns static string')
+    })
+  })
+
+  describe('#validateAddressSingle', async () => {
+    const validateAddress = utilRouteInst.validateAddressSingle
+
+    it('should throw an error for an empty address', async () => {
+      const result = await validateAddress(req, res)
+
+      assert.equal(res.statusCode, 400, 'HTTP status code 400 expected.')
+      assert.include(
+        result.error,
+        'address can not be empty',
+        'Proper error message'
+      )
+    })
+
+    it('should throw 503 when network issues', async () => {
+      // Save the existing RPC URL.
+      const savedUrl2 = process.env.RPC_BASEURL
+
+      // Manipulate the URL to cause a 500 network error.
+      process.env.RPC_BASEURL = 'http://fakeurl/api/'
+
+      req.params.address = 'bchtest:qqqk4y6lsl5da64sg5qc3xezmplyu5kmpyz2ysaa5y'
+
+      await validateAddress(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      // Restore the saved URL.
+      process.env.RPC_BASEURL = savedUrl2
+
+      assert.isAbove(
+        res.statusCode,
+        499,
+        'HTTP status code 500 or greater expected.'
+      )
+      // assert.include(result.error,"Network error: Could not communicate with full node","Error message expected")
+    })
+
+    it('should validate address', async () => {
+      // Mock the RPC call for unit tests.
+      if (process.env.TEST === 'unit') {
+        nock(`${process.env.RPC_BASEURL}`)
+          .post((uri) => uri.includes('/'))
+          .reply(200, { result: mockData.mockAddress })
+      }
+
+      req.params.address =
+        'bitcoincash:qpujxqra3jmdlzzapwmmt7uspr7q0c9ff5hzljcrnd'
+
+      const result = await validateAddress(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.hasAnyKeys(result, [
+        'isvalid',
+        'address',
+        'scriptPubKey',
+        'ismine',
+        'iswatchonly',
+        'isscript'
+      ])
+    })
+  })
+
+  describe('#validateAddressBulk', async () => {
+    const validateAddressBulk = utilRouteInst.validateAddressBulk
+
+    it('should throw an error for an empty body', async () => {
+      const result = await validateAddressBulk(req, res)
+
+      assert.equal(res.statusCode, 400, 'HTTP status code 400 expected.')
+      assert.include(
+        result.error,
+        'addresses needs to be an array. Use GET for single address.',
+        'Proper error message'
+      )
+    })
+
+    it('should error on non-array single address', async () => {
+      req.body = {
+        addresses: 'bchtest:qqqk4y6lsl5da64sg5qc3xezmplyu5kmpyz2ysaa5y'
+      }
+
+      const result = await validateAddressBulk(req, res)
+
+      assert.equal(res.statusCode, 400, 'HTTP status code 400 expected.')
+      assert.include(
+        result.error,
+        'addresses needs to be an array. Use GET for single address.',
+        'Proper error message'
+      )
+    })
+
+    it('should throw 400 error if addresses array is too large', async () => {
+      const testArray = []
+      for (var i = 0; i < 25; i++) testArray.push('')
+
+      req.body.addresses = testArray
+
+      const result = await validateAddressBulk(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.hasAllKeys(result, ['error'])
+      assert.include(result.error, 'Array too large')
+    })
+
+    it('should error on invalid address', async () => {
+      req.body = {
+        addresses: ['bchtest:qqqk4y6lsl5da64sg5qc3xezmpl']
+      }
+
+      const result = await validateAddressBulk(req, res)
+
+      assert.equal(res.statusCode, 400, 'HTTP status code 400 expected.')
+      assert.include(
+        result.error,
+        'Invalid BCH address. Double check your address is valid',
+        'Proper error message'
+      )
+    })
+
+    it('should error on mainnet address when using testnet', async () => {
+      req.body = {
+        addresses: ['bchtest:qrls6vzjkkxlds7aqv9075u0fttwc7u9jvczn5fdt9']
+      }
+
+      const result = await validateAddressBulk(req, res)
+
+      assert.equal(res.statusCode, 400, 'HTTP status code 400 expected.')
+      assert.include(
+        result.error,
+        'Invalid network. Trying to use a testnet address on mainnet, or vice versa.',
+        'Proper error message'
+      )
+    })
+
+    it('should throw 503 when network issues', async () => {
+      // Save the existing RPC URL.
+      const savedUrl2 = process.env.RPC_BASEURL
+
+      // Manipulate the URL to cause a 500 network error.
+      process.env.RPC_BASEURL = 'http://fakeurl/api/'
+
+      req.body.addresses = [
+        'bitcoincash:qpujxqra3jmdlzzapwmmt7uspr7q0c9ff5hzljcrnd'
+      ]
+
+      await validateAddressBulk(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      // Restore the saved URL.
+      process.env.RPC_BASEURL = savedUrl2
+
+      assert.isAbove(
+        res.statusCode,
+        499,
+        'HTTP status code 500 or greater expected.'
+      )
+    })
+
+    it('should validate a single address', async () => {
+      // Mock the RPC call for unit tests.
+      if (process.env.TEST === 'unit') {
+        nock(`${process.env.RPC_BASEURL}`)
+          .post((uri) => uri.includes('/'))
+          .reply(200, { result: mockData.mockAddress })
+      }
+
+      req.body.addresses = [
+        'bitcoincash:qpujxqra3jmdlzzapwmmt7uspr7q0c9ff5hzljcrnd'
+      ]
+
+      const result = await validateAddressBulk(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.isArray(result)
+      assert.hasAnyKeys(result[0], [
+        'isvalid',
+        'address',
+        'scriptPubKey',
+        'ismine',
+        'iswatchonly',
+        'isscript'
+      ])
+    })
+
+    it('should validate a multiple addresses', async () => {
+      // Mock the RPC call for unit tests.
+      if (process.env.TEST === 'unit') {
+        nock(`${process.env.RPC_BASEURL}`)
+          .post((uri) => uri.includes('/'))
+          .times(2)
+          .reply(200, { result: mockData.mockAddress })
+      }
+
+      req.body.addresses = [
+        'bitcoincash:qpujxqra3jmdlzzapwmmt7uspr7q0c9ff5hzljcrnd',
+        'bitcoincash:qpujxqra3jmdlzzapwmmt7uspr7q0c9ff5hzljcrnd'
+      ]
+
+      const result = await validateAddressBulk(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.isArray(result)
+      assert.hasAnyKeys(result[0], [
+        'isvalid',
+        'address',
+        'scriptPubKey',
+        'ismine',
+        'iswatchonly',
+        'isscript'
+      ])
+    })
+  })
+
+  describe('#sweepWif', () => {
+    it('should throw 400 if WIF is not included', async () => {
+      req.body = {}
+
+      const result = await utilRouteInst.sweepWif(req, res)
+
+      assert.equal(res.statusCode, 400, 'HTTP status code 400 expected.')
+      assert.include(
+        result.error,
+        'WIF needs to a proper compressed WIF starting with K or L',
+        'Proper error message'
+      )
+    })
+
+    it('should throw 400 if WIF is malformed', async () => {
+      req.body = {
+        wif: 'abc123'
+      }
+
+      const result = await utilRouteInst.sweepWif(req, res)
+
+      assert.equal(res.statusCode, 400, 'HTTP status code 400 expected.')
+      assert.include(
+        result.error,
+        'WIF needs to a proper compressed WIF starting with K or L',
+        'Proper error message'
+      )
+    })
+
+    it('should throw 400 if destination address is not included', async () => {
+      req.body = {
+        wif: 'L5GEFg1tETLWBugmhSo9Zc4ms968qVmfmTroDxsJ982AiudAQGyt'
+      }
+
+      const result = await utilRouteInst.sweepWif(req, res)
+
+      assert.equal(res.statusCode, 400, 'HTTP status code 400 expected.')
+      assert.include(
+        result.error,
+        'address can not be empty',
+        'Proper error message'
+      )
+    })
+
+    // Unit test only.
+    if (process.env.TEST === 'unit') {
+      it('should generate transaction for valid token sweep', async () => {
+        // Mock the RPC call for unit tests.
+
+        sandbox
+          .stub(utilRouteInst.blockbook, 'balanceFromBlockbook')
+          .resolves(mockData.mockBalance)
+
+        sandbox
+          .stub(utilRouteInst.blockbook, 'utxosFromBlockbook')
+          .resolves(mockData.mockUtxos)
+
+        sandbox
+          .stub(utilRouteInst.bchjs.SLP.Utils, 'tokenUtxoDetails')
+          .resolves(mockData.mockIsTokenUtxos)
+
+        // Mock sendRawTransaction() so that the hex does not actually get broadcast
+        // to the network.
+        sandbox
+          .stub(utilRouteInst.bchjs.RawTransactions, 'sendRawTransaction')
+          .resolves('test-txid')
+
+        req.body = {
+          wif: 'L5GEFg1tETLWBugmhSo9Zc4ms968qVmfmTroDxsJ982AiudAQGyt',
+          toAddr: 'bitcoincash:qz2qn6zt4qmacf4r6c0e2pdcqsgnkxaa3ql2xpee6p'
+        }
+
+        const result = await utilRouteInst.sweepWif(req, res)
+        // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+        assert.equal(result, 'test-txid')
+      })
+
+      it('should return balance if balance-only is true', async () => {
+        // Mock the RPC call for unit tests.
+
+        sandbox
+          .stub(utilRouteInst.blockbook, 'balanceFromBlockbook')
+          .resolves(mockData.mockBalance)
+
+        // Mock sendRawTransaction() so that the hex does not actually get broadcast
+        // to the network.
+        sandbox
+          .stub(utilRouteInst.bchjs.RawTransactions, 'sendRawTransaction')
+          .resolves('test-txid')
+
+        req.body = {
+          wif: 'L5GEFg1tETLWBugmhSo9Zc4ms968qVmfmTroDxsJ982AiudAQGyt',
+          balanceOnly: true
+        }
+
+        const result = await utilRouteInst.sweepWif(req, res)
+        // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+        assert.isNumber(result)
+      })
+    }
+
+    // Unit tests only
+    if (process.env.TEST === 'unit') {
+      it('should generate transaction for valid BCH-only sweep', async () => {
+        sandbox
+          .stub(utilRouteInst.blockbook, 'balanceFromBlockbook')
+          .resolves(mockData.mockBalance)
+
+        sandbox
+          .stub(utilRouteInst.blockbook, 'utxosFromBlockbook')
+          .resolves(mockData.mockUtxos)
+
+        // Force token utxo to appear as regular BCH utxo.
+        sandbox
+          .stub(utilRouteInst.bchjs.SLP.Utils, 'tokenUtxoDetails')
+          .resolves([false, false])
+
+        // Mock sendRawTransaction() so that the hex does not actually get broadcast
+        // to the network.
+        sandbox
+          .stub(utilRouteInst.bchjs.RawTransactions, 'sendRawTransaction')
+          .resolves('test-txid')
+
+        req.body = {
+          wif: 'L5GEFg1tETLWBugmhSo9Zc4ms968qVmfmTroDxsJ982AiudAQGyt',
+          toAddr: 'bitcoincash:qz2qn6zt4qmacf4r6c0e2pdcqsgnkxaa3ql2xpee6p'
+        }
+
+        const result = await utilRouteInst.sweepWif(req, res)
+        // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+        assert.equal(result, 'test-txid')
+      })
+
+      it('should throw 422 error if no non-token UTXOs', async () => {
+        sandbox
+          .stub(utilRouteInst.blockbook, 'balanceFromBlockbook')
+          .resolves(mockData.mockBalance)
+
+        sandbox
+          .stub(utilRouteInst.blockbook, 'utxosFromBlockbook')
+          .resolves(mockData.mockUtxos)
+
+        // Force token utxo to appear as regular BCH utxo.
+        sandbox
+          .stub(utilRouteInst.bchjs.SLP.Utils, 'tokenUtxoDetails')
+          .resolves(mockData.tokensOnly)
+
+        // Mock sendRawTransaction() so that the hex does not actually get broadcast
+        // to the network.
+        sandbox
+          .stub(utilRouteInst.bchjs.RawTransactions, 'sendRawTransaction')
+          .resolves('test-txid')
+
+        req.body = {
+          wif: 'L5GEFg1tETLWBugmhSo9Zc4ms968qVmfmTroDxsJ982AiudAQGyt',
+          toAddr: 'bitcoincash:qz2qn6zt4qmacf4r6c0e2pdcqsgnkxaa3ql2xpee6p'
+        }
+
+        const result = await utilRouteInst.sweepWif(req, res)
+        // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+        assert.equal(res.statusCode, 422)
+        assert.property(result, 'error')
+        assert.include(
+          result.error,
+          'Tokens found, but no BCH UTXOs found. Add BCH to wallet to move tokens'
+        )
+      })
+
+      it('should detect and throw error for multiple token classes', async () => {
+        sandbox
+          .stub(utilRouteInst.blockbook, 'balanceFromBlockbook')
+          .resolves(mockData.mockBalance)
+
+        sandbox
+          .stub(utilRouteInst.blockbook, 'utxosFromBlockbook')
+          .resolves(mockData.mockThreeUtxos)
+
+        // Force token utxo to appear as regular BCH utxo.
+        sandbox
+          .stub(utilRouteInst.bchjs.SLP.Utils, 'tokenUtxoDetails')
+          .resolves(mockData.multipleTokens)
+
+        // Mock sendRawTransaction() so that the hex does not actually get broadcast
+        // to the network.
+        sandbox
+          .stub(utilRouteInst.bchjs.RawTransactions, 'sendRawTransaction')
+          .resolves('test-txid')
+
+        req.body = {
+          wif: 'L5GEFg1tETLWBugmhSo9Zc4ms968qVmfmTroDxsJ982AiudAQGyt',
+          toAddr: 'bitcoincash:qz2qn6zt4qmacf4r6c0e2pdcqsgnkxaa3ql2xpee6p'
+        }
+
+        const result = await utilRouteInst.sweepWif(req, res)
+        // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+        assert.equal(res.statusCode, 422)
+        assert.property(result, 'error')
+        assert.include(
+          result.error,
+          'Multiple token classes detected. This function only supports a single class of token'
+        )
+      })
+    }
+  })
+})

test/v4/xpub.js

@@ -0,0 +1,143 @@
+/*
+  TESTS FOR THE XPUB.JS LIBRARY
+
+  This test file uses the environment variable TEST to switch between unit
+  and integration tests. By default, TEST is set to 'unit'. Set this variable
+  to 'integration' to run the tests against BCH mainnet.
+*/
+
+'use strict'
+
+const chai = require('chai')
+const assert = chai.assert
+const xpubRoute = require('../../src/routes/v4/xpub')
+const nock = require('nock') // HTTP mocking
+
+// let originalUrl // Used during transition from integration to unit tests.
+
+// Mocking data.
+const { mockReq, mockRes } = require('./mocks/express-mocks')
+// const mockData = require('./mocks/address-mock')
+
+// Used for debugging.
+const util = require('util')
+util.inspect.defaultOptions = { depth: 1 }
+
+describe('#XPUBRouter', () => {
+  let req, res
+
+  before(() => {
+    // Set default environment variables for unit tests.
+    if (!process.env.TEST) process.env.TEST = 'unit'
+    // if (process.env.TEST === "unit")
+    //  process.env.BITCOINCOM_BASEURL = "http://fakeurl/api
+  })
+
+  // Setup the mocks before each test.
+  beforeEach(() => {
+    // Mock the req and res objects used by Express routes.
+    req = mockReq
+    res = mockRes
+
+    // Explicitly reset the parmas and body.
+    req.params = {}
+    req.body = {}
+    req.query = {}
+
+    // Activate nock if it's inactive.
+    if (!nock.isActive()) nock.activate()
+  })
+
+  afterEach(() => {
+    // Clean up HTTP mocks.
+    nock.cleanAll() // clear interceptor list.
+    nock.restore()
+  })
+
+  after(() => {
+    // process.env.BITCOINCOM_BASEURL = originalUrl
+  })
+
+  describe('#root', () => {
+    // root route handler.
+    const root = xpubRoute.testableComponents.root
+
+    it('should respond to GET for base route', async () => {
+      const result = root(req, res)
+
+      assert.equal(result.status, 'address', 'Returns static string')
+    })
+  })
+
+  describe('#FromXPubSingle', () => {
+    // details route handler.
+    const fromXPubSingle = xpubRoute.testableComponents.fromXPubSingle
+
+    it('should throw 400 if xpub is empty', async () => {
+      const result = await fromXPubSingle(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.hasAllKeys(result, ['error'])
+      assert.include(result.error, 'xpub can not be empty')
+    })
+
+    it('should error on an array', async () => {
+      req.params.xpub = [
+        'tpubDHTK2jqg73w3GwoiHfAMbMYML1HN8FhrUxD9rFgbSgHXdwwrY6pAFqKDfUHhqw7vreaZty5hPGjb1S7ZPQeMmu6TFHAKfY9tJpYbvaGjPRM'
+      ]
+
+      const result = await fromXPubSingle(req, res)
+
+      assert.equal(res.statusCode, 400, 'HTTP status code 400 expected.')
+      assert.include(
+        result.error,
+        'xpub can not be an array',
+        'Proper error message'
+      )
+    })
+    /*
+    it("should throw 500 when network issues", async () => {
+      const savedUrl = process.env.BITCOINCOM_BASEURL
+
+      try {
+        req.params.xpub = `tpubDHTK2jqg73w3GwoiHfAMbMYML1HN8FhrUxD9rFgbSgHXdwwrY6pAFqKDfUHhqw7vreaZty5hPGjb1S7ZPQeMmu6TFHAKfY9tJpYbvaGjPRM`
+
+        // Switch the Insight URL to something that will error out.
+        process.env.BITCOINCOM_BASEURL = "http://fakeurl/api/"
+
+        const result = await fromXPubSingle(req, res)
+
+        // Restore the saved URL.
+        process.env.BITCOINCOM_BASEURL = savedUrl
+
+        assert.equal(res.statusCode, 500, "HTTP status code 500 expected.")
+        assert.include(result.error, "ENOTFOUND", "Error message expected")
+      } catch (err) {
+        // Restore the saved URL.
+        process.env.BITCOINCOM_BASEURL = savedUrl
+      }
+    })
+*/
+    it('should create an address from xpub', async () => {
+      req.params.xpub = 'tpubDHTK2jqg73w3GwoiHfAMbMYML1HN8FhrUxD9rFgbSgHXdwwrY6pAFqKDfUHhqw7vreaZty5hPGjb1S7ZPQeMmu6TFHAKfY9tJpYbvaGjPRM'
+
+      // Mock the Insight URL for unit tests.
+      // TODO add unit test
+      // if (process.env.TEST === "unit") {
+      //   nock(`${process.env.BITCOINCOM_BASEURL}`)
+      //     .get(
+      //       `/txs/?address=bchtest:qq89kjkeqz9mngp8kl3dpmu43y2wztdjqu500gn4c4&pageNum=0`
+      //     )
+      //     .reply(200, mockData.mockTransactions)
+      // }
+
+      // Call the details API.
+      const result = await fromXPubSingle(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      // Assert that required fields exist in the returned object.
+      assert.exists(result.legacyAddress)
+      assert.exists(result.cashAddress)
+    })
+  })
+})