Merge branch 'master' into bchn

Ct unstable

.gitignore

@@ -20,6 +20,11 @@ start-free-main.sh
 start-local-mainnet.sh.save
 start-local-testnet.sh.save
 temp.sh
+test-fullstack-test.sh
+start-sweet-main.sh
+test-sweet-main.sh
+test-fullstack-abc.sh
+test-fullstack-bchn.sh
 
 coverage
 start-my-infra

config/index.js

@@ -3,7 +3,9 @@
 */
 
 const config = {
-  apiTokenSecret: process.env.TOKENSECRET ? process.env.TOKENSECRET : 'secret-jwt-token'
+  apiTokenSecret: process.env.TOKENSECRET
+    ? process.env.TOKENSECRET
+    : 'secret-jwt-token'
 }
 
 module.exports = config

deploy-production.sh

@@ -1,17 +1,26 @@
+#!/bin/bash
 # Triggers a webhook to update the staging server at staging.fullstack.cash.
 
-#!/bin/bash
 #echo $DEPLOY_SECRET
 
-echo "Deploy to production...."
+# This if statement will only deploy on Jenkins when its testing the master branch.
+echo "-->$GIT_BRANCH<--"
+if [[ $GIT_BRANCH =~ "master" ]]
+  then
 
-export DATA="{\"ref\":\"$DEPLOY_SECRET\"}"
+    echo "Deploying to production...."
 
-#echo $DATA
+    export DATA="{\"ref\":\"$DEPLOY_SECRET\"}"
 
-curl -X POST http://fullstack.cash:9000/hooks/bch-api-mainnet -H "Content-Type: application/json" -d $DATA
-curl -X POST http://fullstack.cash:9000/hooks/bch-api-testnet -H "Content-Type: application/json" -d $DATA
-curl -X POST http://$FREE_SERVER:9000/hooks/bch-api-testnet -H "Content-Type: application/json" -d $DATA
-curl -X POST http://$FREE_SERVER:9000/hooks/bch-api-mainnet -H "Content-Type: application/json" -d $DATA
+    #echo $DATA
 
-echo "...Finished deploying to production."
+    curl -X POST http://fullstack.cash:9000/hooks/bch-api-mainnet -H "Content-Type: application/json" -d $DATA
+    curl -X POST http://fullstack.cash:9000/hooks/bch-api-testnet -H "Content-Type: application/json" -d $DATA
+    curl -X POST http://$FREE_SERVER:9000/hooks/bch-api-testnet -H "Content-Type: application/json" -d $DATA
+    curl -X POST http://$FREE_SERVER:9000/hooks/bch-api-mainnet -H "Content-Type: application/json" -d $DATA
+
+    echo "...Finished deploying to production."
+
+  else
+    echo "Not master, so not deploying."
+fi

package.json

@@ -17,9 +17,9 @@
     "test": "npm run lint && npm run test-v3",
     "lint": "standard --env mocha --fix",
     "test-v3": "export NETWORK=mainnet && nyc --reporter=text mocha --timeout 60000 test/v3/",
-    "test:temp": "export NETWORK=mainnet && mocha --timeout 25000 test/v3/util.js",
+    "test:temp": "export NETWORK=mainnet && mocha --timeout 25000 test/v3/slp.js",
     "test:integration": "mocha test/v3/integration",
-    "test:integration:slpdb": "mocha --timeout 25000 test/v3/integration/slp*.js",
+    "test:integration:slpdb": "mocha --timeout 25000 -g '#validate2Single' test/v3/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"
@@ -28,7 +28,7 @@
     "node": ">=10.15.1"
   },
   "dependencies": {
-    "@psf/bch-js": "^3.5.5",
+    "@psf/bch-js": "^3.7.1",
     "apidoc": "^0.23.0",
     "axios": "^0.19.0",
     "bitcore-lib-cash": "^8.20.3",

src/app.js

@@ -39,6 +39,7 @@ const BlockbookV3 = require('./routes/v3/blockbook')
 const Ninsight = require('./routes/v3/ninsight')
 const ElectrumXV3 = require('./routes/v3/electrumx')
 const EncryptionV3 = require('./routes/v3/encryption')
+const PriceV3 = require('./routes/v3/price')
 
 require('dotenv').config()
 
@@ -52,6 +53,7 @@ const blockbookV3 = new BlockbookV3()
 const electrumxv3 = new ElectrumXV3()
 electrumxv3.connect()
 const encryptionv3 = new EncryptionV3()
+const pricev3 = new PriceV3()
 
 const app = express()
 
@@ -121,6 +123,7 @@ app.use(`/${v3prefix}/` + 'xpub', xpubV3.router)
 app.use(`/${v3prefix}/` + 'blockbook', blockbookV3.router)
 app.use(`/${v3prefix}/` + 'electrumx', electrumxv3.router)
 app.use(`/${v3prefix}/` + 'encryption', encryptionv3.router)
+app.use(`/${v3prefix}/` + 'price', pricev3.router)
 
 const ninsight = new Ninsight()
 app.use(`/${v3prefix}/` + 'ninsight', ninsight.router)

src/middleware/auth.js

@@ -22,9 +22,9 @@
 'use strict'
 
 const passport = require('passport')
-const BasicStrategy = require('passport-http').BasicStrategy
+// const BasicStrategy = require('passport-http').BasicStrategy
 const AnonymousStrategy = require('passport-anonymous')
-const wlogger = require('../util/winston-logging')
+// const wlogger = require('../util/winston-logging')
 
 // Used for debugging and iterrogating JS objects.
 const util = require('util')
@@ -33,9 +33,9 @@ util.inspect.defaultOptions = { depth: 1 }
 // let _this
 
 // Set default rate limit value for testing
-const PRO_PASSES = process.env.PRO_PASS ? process.env.PRO_PASS : 'BITBOX'
+// const PRO_PASSES = process.env.PRO_PASS ? process.env.PRO_PASS : 'BITBOX'
 // Convert the pro-tier password string into an array split by ':'.
-const PRO_PASS = PRO_PASSES.split(':')
+// const PRO_PASS = PRO_PASSES.split(':')
 
 // wlogger.verbose(`PRO_PASS set to: ${PRO_PASS}`)
 
@@ -48,55 +48,55 @@ class AuthMW {
     passport.use(new AnonymousStrategy())
 
     // Initialize passport for 'basic' authentication.
-    passport.use(
-      new BasicStrategy({ passReqToCallback: true }, function (
-        req,
-        username,
-        password,
-        done
-      ) {
-        // console.log(`req: ${util.inspect(req)}`)
-        // console.log(`username: ${username}`)
-        // console.log(`password: ${password}`)
-
-        // Create the req.locals property if it does not yet exist.
-        if (!req.locals) {
-          req.locals = {
-            // default values
-            proLimit: false,
-            apiLevel: 0
-          }
-        }
-
-        // Set pro-tier rate limit to flag to false by default.
-        req.locals.proLimit = false
-
-        // Evaluate the username and password and set the rate limit accordingly.
-        // if (username === "BITBOX" && password === PRO_PASS) {
-        if (username === 'BITBOX') {
-          for (let i = 0; i < PRO_PASS.length; i++) {
-            const thisPass = PRO_PASS[i]
-
-            if (password === thisPass) {
-              wlogger.verbose(`${req.url} called by ${password.slice(0, 6)}`)
-
-              // Success
-              req.locals.proLimit = true
-              break
-            }
-          }
-        }
-
-        // console.log(`req.locals: ${util.inspect(req.locals)}`)
-
-        return done(null, true)
-      })
-    )
+    //   passport.use(
+    //     new BasicStrategy({ passReqToCallback: true }, function (
+    //       req,
+    //       username,
+    //       password,
+    //       done
+    //     ) {
+    //       // console.log(`req: ${util.inspect(req)}`)
+    //       // console.log(`username: ${username}`)
+    //       // console.log(`password: ${password}`)
+    //
+    //       // Create the req.locals property if it does not yet exist.
+    //       if (!req.locals) {
+    //         req.locals = {
+    //           // default values
+    //           proLimit: false,
+    //           apiLevel: 0
+    //         }
+    //       }
+    //
+    //       // Set pro-tier rate limit to flag to false by default.
+    //       req.locals.proLimit = false
+    //
+    //       // Evaluate the username and password and set the rate limit accordingly.
+    //       // if (username === "BITBOX" && password === PRO_PASS) {
+    //       if (username === 'BITBOX') {
+    //         for (let i = 0; i < PRO_PASS.length; i++) {
+    //           const thisPass = PRO_PASS[i]
+    //
+    //           if (password === thisPass) {
+    //             wlogger.verbose(`${req.url} called by ${password.slice(0, 6)}`)
+    //
+    //             // Success
+    //             req.locals.proLimit = true
+    //             break
+    //           }
+    //         }
+    //       }
+    //
+    //       // console.log(`req.locals: ${util.inspect(req.locals)}`)
+    //
+    //       return done(null, true)
+    //     })
+    //   )
   }
 
   // Middleware called by the route.
   mw () {
-    return passport.authenticate(['basic', 'anonymous'], {
+    return passport.authenticate(['anonymous'], {
       session: false
     })
   }

src/middleware/route-ratelimit.js

@@ -20,7 +20,7 @@ const redisClient = new Redis(redisOptions)
 const { RateLimiterRedis } = require('rate-limiter-flexible')
 const rateLimitOptions = {
   storeClient: redisClient,
-  points: 100, // Number of points
+  points: 1000, // Number of points
   duration: 60 // Per minute (per 60 seconds)
 }
 
@@ -98,8 +98,8 @@ class RateLimits {
         wlogger.debug('No JWT token found!')
       }
 
-      // Used for displaying error message. Default value is 3.
-      let rateLimit = 3
+      // Used for displaying error message. Default value is 30.
+      let rateLimit = 30
 
       // Code here for the rate limiter is adapted from this example:
       // https://github.com/animir/node-rate-limiter-flexible/wiki/Overall-example#authorized-and-not-authorized-users
@@ -130,6 +130,15 @@ class RateLimits {
           (origin.toString().indexOf('wallet.fullstack.cash') > -1 ||
             origin.toString().indexOf('sandbox.fullstack.cash') > -1 ||
             origin === 'slp-api')
+        ) {
+          pointsToConsume = 10
+          res.locals.pointsToConsume = pointsToConsume // Feedback for tests.
+        }
+
+        // Apply paid-access rate limits based on key/IP
+        if (
+          key.toString().indexOf('172.17.') > -1 ||
+          key.toString().indexOf('::ffff:127.0.0.1') > -1
         ) {
           pointsToConsume = 1
           res.locals.pointsToConsume = pointsToConsume // Feedback for tests.
@@ -139,7 +148,7 @@ class RateLimits {
           `User ${key} consuming ${pointsToConsume} point for resource ${resource}.`
         )
 
-        rateLimit = Math.floor(100 / pointsToConsume)
+        rateLimit = Math.floor(1000 / pointsToConsume)
 
         // Update the key so that rate limits track both the user and the resource.
         key = `${key}-${resource}`
@@ -169,7 +178,7 @@ class RateLimits {
   // Calculates the points consumed, based on the jwt information and the route
   // requested.
   calcPoints (jwtInfo) {
-    let retVal = 30 // By default, use anonymous tier.
+    let retVal = 300 // By default, use anonymous tier.
 
     try {
       // console.log(`jwtInfo: ${JSON.stringify(jwtInfo, null, 2)}`)
@@ -186,22 +195,22 @@ class RateLimits {
       if (jwtInfo.id) {
         // SLP indexer routes
         if (level40Routes.includes(resource)) {
-          if (apiLevel >= 40) retVal = 1
+          if (apiLevel >= 40) retVal = 10
           // else if (apiLevel >= 10) retVal = 10
-          else retVal = 10
+          else retVal = 100
 
           // Normal indexer routes
         } else if (level30Routes.includes(resource)) {
-          if (apiLevel >= 30) retVal = 1
-          else retVal = 10
+          if (apiLevel >= 30) retVal = 10
+          else retVal = 100
 
           // Full node tier
         } else if (apiLevel >= 20) {
-          retVal = 1
+          retVal = 10
 
           // Free tier, full node only.
         } else {
-          retVal = 10
+          retVal = 100
         }
       }
 
@@ -209,7 +218,7 @@ class RateLimits {
     } catch (err) {
       wlogger.error('Error in route-ratelimit.js/calcPoints()')
       // throw err
-      retVal = 30
+      retVal = 300
     }
 
     return retVal

src/routes/v3/electrumx.js

@@ -52,6 +52,7 @@ class Electrum {
     _this.router.post('/utxos', _this.utxosBulk)
     _this.router.get('/tx/data/:txid', _this.getTransactionDetails)
     _this.router.post('/tx/data', _this.transactionDetailsBulk)
+    _this.router.post('/tx/broadcast', _this.broadcastTransaction)
     _this.router.get('/block/headers/:height', _this.getBlockHeaders)
     _this.router.post('/block/headers', _this.blockHeadersBulk)
     _this.router.get('/balance/:address', _this.getBalance)
@@ -491,6 +492,92 @@ class Electrum {
     }
   }
 
+  // Returns a promise that resolves to transaction ID of the broadcasted transaction or an error.
+  // Expects input to be a txHex string, and input validation to have already
+  // been done by parent, calling function.
+  async _broadcastTransactionWithElectrum (txHex) {
+    try {
+      if (!_this.isReady) {
+        throw new Error(
+          'ElectrumX server connection is not ready. Call await connectToServer() first.'
+        )
+      }
+
+      // Broadcast the transaction hex to the ElectrumX server.
+      const electrumResponse = await _this.electrumx.request(
+        'blockchain.transaction.broadcast',
+        txHex
+      )
+      // console.log(
+      //   `electrumResponse: ${JSON.stringify(electrumResponse, null, 2)}`
+      // )
+
+      return electrumResponse
+    } catch (err) {
+      // console.log('err: ', err)
+
+      // Write out error to error log.
+      wlogger.error(
+        'Error in elecrumx.js/_transactionDetailsFromElectrum(): ',
+        err
+      )
+      throw err
+    }
+  }
+
+  /**
+   * @api {post} /electrumx/tx/broadcast Broadcast a raw transaction
+   * @apiName Broadcast a raw transaction
+   * @apiGroup ElectrumX / Fulcrum
+   * @apiDescription Broadcast a raw transaction and return the transaction ID on success or error on failure.
+   *
+   * @apiExample Example usage:
+   * curl -X POST "https://api.fullstack.cash/v3/electrumx/tx/broadcast" -H "accept: application/json" -H "Content-Type: application/json" -d '{"txHex":"020000000265d13ef402840c8a51f39779afb7ae4d49e4b0a3c24a3d0e7742038f2c679667010000006441dd1dd72770cadede1a7fd0363574846c48468a398ddfa41a9677c74cac8d2652b682743725a3b08c6c2021a629011e11a264d9036e9d5311e35b5f4937ca7b4e4121020797d8fd4d2fa6fd7cdeabe2526bfea2b90525d6e8ad506ec4ee3c53885aa309ffffffff65d13ef402840c8a51f39779afb7ae4d49e4b0a3c24a3d0e7742038f2c679667000000006441347d7f218c11c04487c1ad8baac28928fb10e5054cd4494b94d078cfa04ccf68e064fb188127ff656c0b98e9ce87f036d183925d0d0860605877d61e90375f774121028a53f95eb631b460854fc836b2e5d31cad16364b4dc3d970babfbdcc3f2e4954ffffffff035ac355000000000017a914189ce02e332548f4804bac65cba68202c9dbf822878dfd0800000000001976a914285bb350881b21ac89724c6fb6dc914d096cd53b88acf9ef3100000000001976a91445f1f1c4a9b9419a5088a3e9c24a293d7a150e6488ac00000000"}'
+   *
+   */
+  // POST handler for broadcasting a single transaction
+  async broadcastTransaction (req, res, next) {
+    try {
+      const txHex = req.body.txHex
+
+      if (typeof txHex !== 'string') {
+        res.status(400)
+        return res.json({
+          success: false,
+          error: 'request body must be a string.'
+        })
+      }
+
+      wlogger.debug(
+        'Executing electrumx/broadcastTransaction with this tx hex: ',
+        txHex
+      )
+
+      // Get data from ElectrumX server.
+      const electrumResponse = await _this._broadcastTransactionWithElectrum(txHex)
+      // console.log(`_utxosFromElectrumx(): ${JSON.stringify(electrumResponse, null, 2)}`)
+
+      // Pass the error message if ElectrumX reports an error.
+      if (electrumResponse instanceof Error) {
+        res.status(400)
+        return res.json({
+          success: false,
+          error: electrumResponse.message
+        })
+      }
+
+      res.status(200)
+      return res.json({
+        success: true,
+        txid: electrumResponse
+      })
+    } catch (err) {
+      wlogger.error('Error in electrumx.js/broadcastTransaction().', err)
+
+      return _this.errorHandler(err, res)
+    }
+  }
+
   // Returns a promise that resolves to block header data for a block height.
   // Expects input to be a height number, and input validation to have already
   // been done by parent, calling function.

src/routes/v3/price.js

@@ -0,0 +1,118 @@
+/*
+  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.router = express.Router()
+    this.router.get('/', _this.root)
+    this.router.get('/usd', _this.getUSD)
+    this.router.get('/rates', _this.getBCHRate)
+  }
+
+  // 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
+   *
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v3/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
+   *
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v3/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)
+    }
+  }
+}
+
+module.exports = Price

src/routes/v3/slp.js

@@ -13,8 +13,12 @@ const Slpdb = require('./services/slpdb')
 // const strftime = require('strftime')
 const wlogger = require('../../util/winston-logging')
 
+// Instantiate a local copy of bch-js using the local REST API server.
+const LOCAL_RESTURL = process.env.LOCAL_RESTURL
+  ? process.env.LOCAL_RESTURL
+  : 'https://api.fullstack.cash/v3/'
 const BCHJS = require('@psf/bch-js')
-const bchjs = new BCHJS()
+const bchjs = new BCHJS({ restURL: LOCAL_RESTURL })
 
 // Used to convert error messages to strings, to safely pass to users.
 const util = require('util')
@@ -48,6 +52,7 @@ class Slp {
   constructor () {
     _this = this
 
+    // Encapsulate external libraries.
     _this.axios = axios
     _this.routeUtils = routeUtils
     _this.BigNumber = BigNumber
@@ -68,6 +73,7 @@ class Slp {
     _this.router.post('/convert', _this.convertAddressBulk)
     _this.router.post('/validateTxid', _this.validateBulk)
     _this.router.get('/validateTxid/:txid', _this.validateSingle)
+    _this.router.get('/validateTxid2/:txid', _this.validate2Single)
     _this.router.get('/txDetails/:txid', _this.txDetails)
     _this.router.get('/tokenStats/:tokenId', _this.tokenStats)
     _this.router.get(
@@ -1059,7 +1065,7 @@ class Slp {
    * @api {get} /slp/validateTxid/{txid}  Validate single SLP transaction by txid.
    * @apiName Validate single SLP transaction by txid.
    * @apiGroup SLP
-   * @apiDescription Validate single SLP transaction by txid.
+   * @apiDescription Validate single SLP transaction by txid, using SLPDB.
    *
    *
    * @apiExample Example usage:
@@ -1132,11 +1138,66 @@ class Slp {
     }
   }
 
-  // Returns a Boolean if the input TXID is a valid SLP TXID.
-  // async function isValidSlpTxid (txid) {
-  //   const isValid = await slpValidator.isValidSlpTxid(txid)
-  //   return isValid
-  // }
+  /**
+   * @api {get} /slp/validateTxid2/{txid}  Validate single SLP transaction by txid.
+   * @apiName Validate single SLP transaction by txid.
+   * @apiGroup SLP
+   * @apiDescription Validate single SLP transaction by txid, using slp-validate.
+   * Slower, less efficient method of validating an SLP TXID using the slp-validate
+   * npm library. This method is independent of SLPDB and can be used as a fall-back
+   * when SLPDB returns 'null' values.
+   *
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v3/slp/validateTxid2/f7e5199ef6669ad4d078093b3ad56e355b6ab84567e59ad0f08a5ad0244f783a" -H "accept:application/json"
+   *
+   *
+   */
+  async validate2Single (req, res, next) {
+    try {
+      const txid = req.params.txid
+
+      // Validate input
+      if (!txid || txid === '') {
+        res.status(400)
+        return res.json({ error: 'txid can not be empty' })
+      }
+
+      wlogger.debug(
+        'Executing slp/validate2Single/:txid with this txid: ',
+        txid
+      )
+
+      // null by default.
+      // Default return value.
+      const result = {
+        txid: txid,
+        isValid: null,
+        msg: ''
+      }
+
+      // Request options
+      const opt = {
+        method: 'get',
+        baseURL: `${process.env.SLP_API_URL}slp/validate/${txid}`,
+        timeout: 10000 // Exit after 10 seconds.
+      }
+      const tokenRes = await _this.axios.request(opt)
+      // console.log(`tokenRes.data: ${JSON.stringify(tokenRes.data, null, 2)}`)
+      // console.log(`tokenRes: `, tokenRes)
+
+      // Overwrite the default value with the result from slp-api.
+      result.isValid = tokenRes.data.isValid
+
+      res.status(200)
+      return res.json(result)
+    } catch (err) {
+      // console.log('validate2Single error: ', err)
+      wlogger.error('Error in slp.ts/validate2Single().', err)
+
+      return _this.errorHandler(err, res)
+    }
+  }
 
   /**
    * @api {get} /slp/txDetails/{txid}  SLP transaction details.
@@ -1537,7 +1598,7 @@ class Slp {
    * not been confirmed.
    *
    * @apiExample Example usage:
-   * curl -X POST "https://api.fullstack.cash/v3/slp/hydrateUtxos" -H "accept:application/json" -H "Content-Type: application/json" -d '{"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}]}'
+   * curl -X POST "https://api.fullstack.cash/v3/slp/hydrateUtxos" -H "accept:application/json" -H "Content-Type: application/json" -d '{"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}]}]}'
    *
    *
    */
@@ -1567,6 +1628,13 @@ class Slp {
         })
       }
 
+      if (!utxos[0].utxos) {
+        res.status(422)
+        return res.json({
+          error: 'Each element in array should have a utxos property'
+        })
+      }
+
       // Loop through each address and query the UTXOs for that element.
       for (let i = 0; i < utxos.length; i++) {
         const theseUtxos = utxos[i].utxos
@@ -1583,6 +1651,7 @@ class Slp {
       return res.json({ slpUtxos: utxos })
     } catch (err) {
       wlogger.error('Error in slp.js/hydrateUtxos().', err)
+      console.error('Error in slp.js/hydrateUtxos().', err)
 
       // Decode the error message.
       const { msg, status } = routeUtils.decodeError(err)

test/v3/a01-electrumx.js

@@ -906,6 +906,92 @@ describe('#ElectrumX Router', () => {
     })
   })
 
+  describe('#_broadcastTransactionWithElectrum', () => {
+    it('should return error object for invalid formatted transaction', async () => {
+      const invalidHex = mockData.txDetails.hex.substring(10)
+
+      stubMethodForUnitTests(
+        electrumxRoute.electrumx,
+        'request',
+        new Error('Error: the transaction was rejected by network rules.\n\nTX decode failed\n')
+      )
+
+      const result = await electrumxRoute._broadcastTransactionWithElectrum(invalidHex)
+
+      assert.instanceOf(result, Error)
+      assert.include(result.message, 'TX decode failed')
+    })
+
+    it('should return txid for valid transaction', async function () {
+      // We cannot send an actual broadcast transaction to mainnet
+      if (process.env.TEST !== 'unit') return this.skip()
+
+      const validHex = mockData.txDetails.hex
+
+      stubMethodForUnitTests(
+        electrumxRoute.electrumx,
+        'request',
+        mockData.txDetails.hash
+      )
+
+      const result = await electrumxRoute._broadcastTransactionWithElectrum(validHex)
+
+      assert.typeOf(result, 'string')
+      assert.equal(result, mockData.txDetails.hash)
+    })
+  })
+
+  describe('#broadcastTransaction', () => {
+    it('should throw an error for a non-string', async () => {
+      req.body = 456
+
+      stubMethodForUnitTests(
+        electrumxRoute,
+        '_broadcastTransactionWithElectrum',
+        new Error('request body must be a string.')
+      )
+
+      const result = await electrumxRoute.broadcastTransaction(req, res)
+
+      expectRouteError(res, result, 'request body must be a string.')
+    })
+
+    it('should throw an error object for invalid formatted transaction', async () => {
+      req.body.txHex = mockData.txDetails.hex.substring(10)
+
+      stubMethodForUnitTests(
+        electrumxRoute,
+        '_broadcastTransactionWithElectrum',
+        new Error('Error: the transaction was rejected by network rules.\n\nTX decode failed\n')
+      )
+
+      const result = await electrumxRoute.broadcastTransaction(req, res)
+
+      expectRouteError(res, result, 'TX decode failed')
+    })
+
+    it('should return txid for valid transaction', async function () {
+      // We cannot send an actual broadcast transaction to mainnet
+      if (process.env.TEST !== 'unit') return this.skip()
+
+      req.body.txHex = mockData.txDetails.hex
+
+      stubMethodForUnitTests(
+        electrumxRoute,
+        '_broadcastTransactionWithElectrum',
+        mockData.txDetails.hash
+      )
+
+      const result = await electrumxRoute.broadcastTransaction(req, res)
+
+      assert.property(result, 'success')
+      assert.equal(result.success, true)
+
+      assert.property(result, 'txid')
+      assert.equal(result.txid, mockData.txDetails.hash)
+    })
+  })
+
   describe('#_balanceFromElectrumx', () => {
     it('should throw error for invalid address', async () => {
       try {

test/v3/integration/price.js

@@ -0,0 +1,34 @@
+/*
+  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/v3/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)}`)
+    })
+  })
+})

test/v3/integration/rate-limits.js

@@ -16,9 +16,10 @@ util.inspect.defaultOptions = { depth: 1 }
 
 // const SERVER = `http://192.168.0.36:12400/v3/`
 const SERVER = 'http://localhost:3000/v3/'
+// const SERVER = 'https://api.fullstack.cash/v3/'
 
 const TEST_JWT =
-  'eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjVlM2EwNDE1ZWIyOWE5NjJkYTI3MDhiNCIsImFwaUxldmVsIjowLCJyYXRlTGltaXQiOjEwLCJpYXQiOjE1ODA4NjA0NjcsImV4cCI6MTU4MzQ1MjQ2N30.fuY5S-YrF0J11h5uyMjPe7wiVkYRnIyXi4dL9-V-C6pLJm33p0dSq_pSheVVWw78n5kAvL_9kFHngbnmQiOJYQ'
+  'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjVlODhhY2JmMDIyMWMxMDAxMmFkOTNmZiIsImVtYWlsIjoiY2hyaXMudHJvdXRuZXJAZ21haWwuY29tIiwiYXBpTGV2ZWwiOjQwLCJyYXRlTGltaXQiOjMsImlhdCI6MTYwMDYyODk1MSwiZXhwIjoxNjAzMjIwOTUxfQ.JPXDJQsxJFtCGZjHOd-hRfJuY41Ef_FQ4ET06CtYdNk'
 
 describe('#rate limits', () => {
   it('should get control/getNetworkInfo() with no auth', async () => {
@@ -35,7 +36,7 @@ describe('#rate limits', () => {
     assert.hasAnyKeys(result.data, ['version'])
   })
 
-  it('should trigger rate-limit handler if rate limits exceeds 30 request per minute', async () => {
+  it('should trigger rate-limit handler if rate limits exceeds 5 request per minute', async () => {
     try {
       // Actual rate limit is 60 per minute X 4 nodes = 240 rpm.
       const options = {
@@ -44,7 +45,7 @@ describe('#rate limits', () => {
       }
 
       const promises = []
-      for (let i = 0; i < 30; i++) {
+      for (let i = 0; i < 5; i++) {
         const promise = axios(options)
         promises.push(promise)
       }
@@ -60,79 +61,79 @@ describe('#rate limits', () => {
     }
   })
 
-  it('should not trigger rate-limit handler if correct pro-tier password is used', async () => {
-    try {
-      const username = 'BITBOX'
+  // 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?'
+  //     )
+  //   }
+  // })
 
-      // 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 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 {

test/v3/integration/slp.js

@@ -213,4 +213,49 @@ describe('#slp', () => {
       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'
+    //   )
+    // })
+  })
 })

test/v3/mocks/price-mock.js

@@ -0,0 +1,221 @@
+/*
+  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'
+    }
+  }
+}
+
+module.exports = {
+  mockCoinbaseFeed
+}

test/v3/mocks/slp-mocks.js

@@ -352,7 +352,8 @@ const mockTxHistory = [
         e: {
           h: '7bdd586ebd1e5f3dfd5295ab6e896c48b25855ab77a72c035ce1e7aacc965c2d',
           i: 1,
-          s: 'RzBEAiAsu5o9EnxgZChjxKygxhGLhlfxJJbQfd4PP/vp2od3fAIgPpMqg+Sp4YpiInQZ6weJwELq8LEIrHXJpueBz7yF5gRBIQLsyL3809mRphc/+tPAcTQO5bi0kqZRFKpKIHXE3qN8Rw==',
+          s:
+            'RzBEAiAsu5o9EnxgZChjxKygxhGLhlfxJJbQfd4PP/vp2od3fAIgPpMqg+Sp4YpiInQZ6weJwELq8LEIrHXJpueBz7yF5gRBIQLsyL3809mRphc/+tPAcTQO5bi0kqZRFKpKIHXE3qN8Rw==',
           a: 'simpleledger:qrrrpqmdkggpnw0czwg0jgcjd7yhu25jy5zxh2gqdq'
         }
       },
@@ -361,7 +362,8 @@ const mockTxHistory = [
         e: {
           h: 'df49feff24dc34a10a44a0cbd7c908d964801ec7218512c84574fbce698535f0',
           i: 3,
-          s: 'SDBFAiEAhW3zbKTlPrOXD2E2oEcNof6vCMPGYIg8vOVSE9c8IakCIFLg/gxydG9eL8HMAzkScGElKWJRnfhVMpMHU3evNcrZQSEDRS7F+pSC8OxSldsT4FctJLZBU7f2+FDiE05ae1xqtN0=',
+          s:
+            'SDBFAiEAhW3zbKTlPrOXD2E2oEcNof6vCMPGYIg8vOVSE9c8IakCIFLg/gxydG9eL8HMAzkScGElKWJRnfhVMpMHU3evNcrZQSEDRS7F+pSC8OxSldsT4FctJLZBU7f2+FDiE05ae1xqtN0=',
           a: 'simpleledger:qpkpeqfslejw5pptzcy25h2jxhsc9k0vts43n26up0'
         }
       }
@@ -371,7 +373,8 @@ const mockTxHistory = [
         e: {
           v: 0,
           i: 0,
-          s: 'agRTTFAAAQEEU0VORCA46XxdfTWFosvz+VgMgsozmF+csIRdTcziIMtwn5U4sAgAAAAAAJiWgAgAAAAAJHfU+g=='
+          s:
+            'agRTTFAAAQEEU0VORCA46XxdfTWFosvz+VgMgsozmF+csIRdTcziIMtwn5U4sAgAAAAAAJiWgAgAAAAAJHfU+g=='
         }
       },
       {
@@ -402,7 +405,8 @@ const mockTxHistory = [
     slp: {
       detail: {
         decimals: 8,
-        tokenIdHex: '38e97c5d7d3585a2cbf3f9580c82ca33985f9cb0845d4dcce220cb709f9538b0',
+        tokenIdHex:
+          '38e97c5d7d3585a2cbf3f9580c82ca33985f9cb0845d4dcce220cb709f9538b0',
         transactionType: 'SEND',
         versionType: 1,
         documentUri: 'psfoundation.cash',
@@ -439,7 +443,8 @@ const mockTxHistory = [
         e: {
           h: 'e4e1e1f6b502cbd42f69b919634cea3e37fc8595e6ca800e0a7d8f6dcdfb249e',
           i: 3,
-          s: 'SDBFAiEAjCGRmU28x24LMTwg5XqC+fLf3zGhTYCsSWpmF8Eshq0CIAJhxAKMbwKWC4ASmjWzplpno2ch+hGNUD6HNWOdbd4SQSECeRsZo5Fl29g0A9bfJo1E/WIdowWBsLblyxWnEB7ViFE=',
+          s:
+            'SDBFAiEAjCGRmU28x24LMTwg5XqC+fLf3zGhTYCsSWpmF8Eshq0CIAJhxAKMbwKWC4ASmjWzplpno2ch+hGNUD6HNWOdbd4SQSECeRsZo5Fl29g0A9bfJo1E/WIdowWBsLblyxWnEB7ViFE=',
           a: 'simpleledger:qpvsg9vl9a5mlf37a7n3yce6pktdctn73qznkmw3s7'
         }
       },
@@ -448,7 +453,8 @@ const mockTxHistory = [
         e: {
           h: '438420345dd8b7fb4ea74aaf2e3090f44899bf3c71662243946a441de6dae720',
           i: 2,
-          s: 'SDBFAiEAhmLYL4QY3mvZo3/i0XG9PJAYMruw3MaGOLJ3Z4si7hwCIAaaGwRnj/cZK3L/KKFBoMtItpGRZ10GowNN//vgn6PKQSECeRsZo5Fl29g0A9bfJo1E/WIdowWBsLblyxWnEB7ViFE=',
+          s:
+            'SDBFAiEAhmLYL4QY3mvZo3/i0XG9PJAYMruw3MaGOLJ3Z4si7hwCIAaaGwRnj/cZK3L/KKFBoMtItpGRZ10GowNN//vgn6PKQSECeRsZo5Fl29g0A9bfJo1E/WIdowWBsLblyxWnEB7ViFE=',
           a: 'simpleledger:qpvsg9vl9a5mlf37a7n3yce6pktdctn73qznkmw3s7'
         }
       }
@@ -458,7 +464,8 @@ const mockTxHistory = [
         e: {
           v: 0,
           i: 0,
-          s: 'agRTTFAAAQEEU0VORCCk+1wtoaoGTiUBikP5FlBABx2emEuhkMIip/WQU6+EsggAAAAAAA9CQAgAAAAXQnHEwA=='
+          s:
+            'agRTTFAAAQEEU0VORCCk+1wtoaoGTiUBikP5FlBABx2emEuhkMIip/WQU6+EsggAAAAAAA9CQAgAAAAXQnHEwA=='
         }
       },
       {
@@ -489,7 +496,8 @@ const mockTxHistory = [
     slp: {
       detail: {
         decimals: 2,
-        tokenIdHex: 'a4fb5c2da1aa064e25018a43f9165040071d9e984ba190c222a7f59053af84b2',
+        tokenIdHex:
+          'a4fb5c2da1aa064e25018a43f9165040071d9e984ba190c222a7f59053af84b2',
         transactionType: 'SEND',
         versionType: 1,
         documentUri: 'troutsblog.com',

test/v3/price.js

@@ -0,0 +1,214 @@
+/*
+  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/v3/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')
+    })
+  })
+})

test/v3/rate-limits.js

@@ -105,14 +105,14 @@ describe('#route-ratelimits & jwt-auth', () => {
   })
 
   describe('#calcPoints', () => {
-    it('should return 30 points for anonymous user', () => {
+    it('should return 300 points for anonymous user', () => {
       const result = rateLimits.calcPoints()
       // console.log(`result: ${result}`)
 
-      assert.equal(result, 30)
+      assert.equal(result, 300)
     })
 
-    it('should return 10 points for free tier requesting full node access', () => {
+    it('should return 100 points for free tier requesting full node access', () => {
       const jwtInfo = {
         apiLevel: 10,
         resource: 'blockchain',
@@ -120,10 +120,10 @@ describe('#route-ratelimits & jwt-auth', () => {
       }
 
       const result = rateLimits.calcPoints(jwtInfo)
-      assert.equal(result, 10)
+      assert.equal(result, 100)
     })
 
-    it('should return 10 points for free tier requesting indexer access', () => {
+    it('should return 100 points for free tier requesting indexer access', () => {
       const jwtInfo = {
         apiLevel: 10,
         resource: 'blockbook',
@@ -131,10 +131,10 @@ describe('#route-ratelimits & jwt-auth', () => {
       }
 
       const result = rateLimits.calcPoints(jwtInfo)
-      assert.equal(result, 10)
+      assert.equal(result, 100)
     })
 
-    it('should return 10 points for free tier requesting SLPDB access', () => {
+    it('should return 100 points for free tier requesting SLPDB access', () => {
       const jwtInfo = {
         apiLevel: 10,
         resource: 'slp',
@@ -142,10 +142,10 @@ describe('#route-ratelimits & jwt-auth', () => {
       }
 
       const result = rateLimits.calcPoints(jwtInfo)
-      assert.equal(result, 10)
+      assert.equal(result, 100)
     })
 
-    it('should return 1 point for full node tier requesting full node access', () => {
+    it('should return 10 points for full node tier requesting full node access', () => {
       const jwtInfo = {
         apiLevel: 20,
         resource: 'blockchain',
@@ -153,10 +153,10 @@ describe('#route-ratelimits & jwt-auth', () => {
       }
 
       const result = rateLimits.calcPoints(jwtInfo)
-      assert.equal(result, 1)
+      assert.equal(result, 10)
     })
 
-    it('should return 10 points for full-node tier requesting indexer access', () => {
+    it('should return 100 points for full-node tier requesting indexer access', () => {
       const jwtInfo = {
         apiLevel: 20,
         resource: 'blockbook',
@@ -164,10 +164,10 @@ describe('#route-ratelimits & jwt-auth', () => {
       }
 
       const result = rateLimits.calcPoints(jwtInfo)
-      assert.equal(result, 10)
+      assert.equal(result, 100)
     })
 
-    it('should return 10 points for full node tier requesting SLPDB access', () => {
+    it('should return 100 points for full node tier requesting SLPDB access', () => {
       const jwtInfo = {
         apiLevel: 20,
         resource: 'slp',
@@ -175,10 +175,10 @@ describe('#route-ratelimits & jwt-auth', () => {
       }
 
       const result = rateLimits.calcPoints(jwtInfo)
-      assert.equal(result, 10)
+      assert.equal(result, 100)
     })
 
-    it('should return 1 point for indexer tier requesting full node access', () => {
+    it('should return 10 point for indexer tier requesting full node access', () => {
       const jwtInfo = {
         apiLevel: 30,
         resource: 'blockchain',
@@ -186,32 +186,32 @@ describe('#route-ratelimits & jwt-auth', () => {
       }
 
       const result = rateLimits.calcPoints(jwtInfo)
-      assert.equal(result, 1)
+      assert.equal(result, 10)
     })
 
-    it('should return 1 points for indexer tier requesting indexer access', () => {
+    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, 1)
-    })
-
-    it('should return 10 points for indexer tier requesting SLPDB access', () => {
-      const jwtInfo = {
-        apiLevel: 30,
-        resource: 'slp',
-        id: '5e3a0415eb29a962da2708b4'
-      }
-
       const result = rateLimits.calcPoints(jwtInfo)
       assert.equal(result, 10)
     })
 
-    it('should return 1 point for SLP tier requesting full node access', () => {
+    it('should return 100 points for indexer tier requesting SLPDB access', () => {
+      const jwtInfo = {
+        apiLevel: 30,
+        resource: 'slp',
+        id: '5e3a0415eb29a962da2708b4'
+      }
+
+      const result = rateLimits.calcPoints(jwtInfo)
+      assert.equal(result, 100)
+    })
+
+    it('should return 10 point for SLP tier requesting full node access', () => {
       const jwtInfo = {
         apiLevel: 40,
         resource: 'blockchain',
@@ -219,10 +219,10 @@ describe('#route-ratelimits & jwt-auth', () => {
       }
 
       const result = rateLimits.calcPoints(jwtInfo)
-      assert.equal(result, 1)
+      assert.equal(result, 10)
     })
 
-    it('should return 1 points for SLP tier requesting indexer access', () => {
+    it('should return 10 points for SLP tier requesting indexer access', () => {
       const jwtInfo = {
         apiLevel: 40,
         resource: 'blockbook',
@@ -230,10 +230,10 @@ describe('#route-ratelimits & jwt-auth', () => {
       }
 
       const result = rateLimits.calcPoints(jwtInfo)
-      assert.equal(result, 1)
+      assert.equal(result, 10)
     })
 
-    it('should return 1 points for SLP tier requesting SLPDB access', () => {
+    it('should return 10 points for SLP tier requesting SLPDB access', () => {
       const jwtInfo = {
         apiLevel: 40,
         resource: 'slp',
@@ -241,7 +241,7 @@ describe('#route-ratelimits & jwt-auth', () => {
       }
 
       const result = rateLimits.calcPoints(jwtInfo)
-      assert.equal(result, 1)
+      assert.equal(result, 10)
     })
   })
 
@@ -442,7 +442,7 @@ describe('#route-ratelimits & jwt-auth', () => {
 
       // Issues with token secret should treat incoming requests as anonymous
       // calls with 30 points or 3 RPM.
-      assert.equal(res.locals.pointsToConsume, 30)
+      assert.equal(res.locals.pointsToConsume, 300)
     })
   })
 })

test/v3/raw-transactions.js

@@ -975,6 +975,7 @@ describe('#Raw-Transactions', () => {
       // Restore the saved URL.
       process.env.RPC_BASEURL = savedUrl2
     })
+
     it('should submit hex encoded transaction', async () => {
       // This is a difficult test to run as transaction hex is invalid after a
       // block confirmation. So the unit tests simulates what the output 'should'

test/v3/slp.js

@@ -362,6 +362,7 @@ describe('#SLP', () => {
       assert.hasAllKeys(result, ['error'])
       assert.include(result.error, 'Array too large')
     })
+
     it('returns proper error when downstream service stalls', async () => {
       // Mock the timeout error.
       sandbox.stub(slpRoute.axios, 'request').throws({ code: 'ECONNABORTED' })
@@ -462,6 +463,80 @@ describe('#SLP', () => {
     })
   })
 
+  describe('#validate2Single', () => {
+    it('should throw 400 if txid is empty', async () => {
+      req.params.txid = ''
+      const result = await slpRoute.validate2Single(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.hasAllKeys(result, ['error'])
+      assert.include(result.error, 'txid can not be empty')
+    })
+
+    it('should invalidate a known invalid TXID', async () => {
+      if (process.env.TEST === 'unit') {
+        // Mock to prevent live network connection.
+        sandbox
+          .stub(slpRoute.axios, 'request')
+          .resolves({ data: { isValid: false } })
+      }
+
+      const txid =
+        'f7e5199ef6669ad4d078093b3ad56e355b6ab84567e59ad0f08a5ad0244f783a'
+
+      req.params.txid = txid
+      const result = await slpRoute.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 () => {
+      if (process.env.TEST === 'unit') {
+        // Mock to prevent live network connection.
+        sandbox
+          .stub(slpRoute.axios, 'request')
+          .resolves({ data: { isValid: true } })
+      }
+
+      const txid =
+        '3a4b628cbcc183ab376d44ce5252325f042268307ffa4a53443e92b6d24fb488'
+
+      req.params.txid = txid
+      const result = await slpRoute.validate2Single(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.equal(result.txid, txid)
+      assert.equal(result.isValid, true)
+    })
+
+    // This test can only be run as a mocked unit test. It's too inconsistent
+    // to run as an integration test, due to the caching built into slp-validate.
+    if (process.env.TEST === 'unit') {
+      it('should cancel if validation takes too long', async () => {
+        // Mock the timeout error.
+        sandbox.stub(slpRoute.axios, 'request').throws({
+          code: 'ECONNABORTED'
+        })
+
+        const txid =
+          'eacb1085dfa296fef6d4ae2c0f4529a1bef096dd2325bdcc6dcb5241b3bdb579'
+
+        req.params.txid = txid
+        const result = await slpRoute.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('tokenStats()', () => {
     it('should throw 400 if tokenID is empty', async () => {
       req.params.tokenId = ''
@@ -1034,6 +1109,34 @@ describe('#SLP', () => {
       assert.property(result.slpUtxos[0].utxos[1], 'tokenType')
       assert.property(result.slpUtxos[0].utxos[1], 'tokenQty')
     })
+
+    it('should throw error for missing properties', async () => {
+      const utxos = [
+        {
+          height: 639443,
+          tx_hash:
+            '30707fffb9b295a06a68d217f49c198e9e1dbe1edc3874a0928ca1905f1709df',
+          tx_pos: 0,
+          value: 6000
+        },
+        {
+          height: 639443,
+          tx_hash:
+            '8962566e413501224d178a02effc89be5ac0d8e4195f617415d443dc4c38fe50',
+          tx_pos: 1,
+          value: 546
+        }
+      ]
+
+      req.body.utxos = utxos
+      const result = await slpRoute.hydrateUtxos(req, res)
+
+      assert.hasAllKeys(result, ['error'])
+      assert.include(
+        result.error,
+        'Each element in array should have a utxos property'
+      )
+    })
   })
 })