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

fix(docs): Fixing some visual issues with the docs

package.json

@@ -17,7 +17,8 @@
     "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 && export TEST=integration && mocha --timeout 25000 test/v3/integration/price.js",
+    "test:temp:integration": "export NETWORK=mainnet && export TEST=integration && mocha --timeout 25000 test/v3/integration/price.js",
+    "test:temp:unit": "export NETWORK=mainnet && mocha -g '#validateBulk' --exit test/v3/",
     "test:integration": "mocha test/v3/integration",
     "test:integration:slpdb": "mocha --timeout 25000 -g '#validate2Single' test/v3/integration/slp*.js",
     "coverage": "nyc report --reporter=text-lcov | coveralls",

src/middleware/route-ratelimit.js

@@ -146,10 +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.toString().indexOf('fullstack.cash') > -1 ||
               origin.toString().indexOf('splitbch.com') > -1 ||
-              origin === 'slp-api')
+              origin.toString().indexOf('slp-api') > -1)
           ) {
             pointsToConsume = 10
             res.locals.pointsToConsume = pointsToConsume // Feedback for tests.
@@ -159,7 +158,6 @@ class RateLimits {
           if (
             // Comment out the line below when running bch-js e2e rate limit tests.
             key.toString().indexOf('::ffff:127.0.0.1') > -1 ||
-
             // Do not comment out this line.
             key.toString().indexOf('172.17.') > -1
           ) {

src/routes/v3/slp.js

@@ -74,6 +74,9 @@ class Slp {
     _this.router.post('/validateTxid', _this.validateBulk)
     _this.router.get('/validateTxid/:txid', _this.validateSingle)
     _this.router.get('/validateTxid2/:txid', _this.validate2Single)
+    _this.router.get('/validateTxid3/:txid', _this.validate3Single)
+    _this.router.post('/validateTxid3', _this.validate3Bulk)
+    _this.router.get('/whitelist', _this.getSlpWhitelist)
     _this.router.get('/txDetails/:txid', _this.txDetails)
     _this.router.get('/tokenStats/:tokenId', _this.tokenStats)
     _this.router.get(
@@ -987,6 +990,7 @@ class Slp {
       const s = JSON.stringify(query)
       const b64 = Buffer.from(s).toString('base64')
       const url = `${process.env.SLPDB_URL}q/${b64}`
+      // console.log('url: ', url)
 
       const options = _this.generateCredentials()
 
@@ -1002,7 +1006,7 @@ class Slp {
 
       let formattedTokens = []
 
-      // Combine the arrays. Why? Generally there is nothing in the u array.
+      // Combine the confirmed and unconfirmed collections.
       const concatArray = tokenRes.data.c.concat(tokenRes.data.u)
 
       const tokenIds = []
@@ -1024,12 +1028,15 @@ class Slp {
         })
 
         // If a user-provided txid doesn't exist in the data, add it with
-        // valid:false property.
+        // valid:null property.
+        // 'null' indicates that SLPDB does not know about the transaction. It
+        // either has not seen it or has not processed it yet. A determination
+        // can not be made.
         txids.forEach((txid) => {
           if (!tokenIds.includes(txid)) {
             formattedTokens.push({
               txid: txid,
-              valid: false
+              valid: null
             })
           }
         })
@@ -1052,8 +1059,21 @@ class Slp {
         formattedTokens = newOutput
       }
 
+      // Put the output array in the same order as the input array.
+      const outAry = []
+      for (let i = 0; i < txids.length; i++) {
+        const thisTxid = txids[i]
+
+        // Need to use Array.find() because the returned output array is out
+        // of order with respect to the txid input array.
+        const output = formattedTokens.find((elem) => elem.txid === thisTxid)
+        // console.log(`output: ${JSON.stringify(output, null, 2)}`)
+
+        outAry.push(output)
+      }
+
       res.status(200)
-      return res.json(formattedTokens)
+      return res.json(outAry)
     } catch (err) {
       wlogger.error('Error in slp.ts/validateBulk().', err)
 
@@ -1110,11 +1130,12 @@ class Slp {
       }
       // Get data from SLPDB.
       const tokenRes = await _this.axios.request(opt)
+      // console.log(`tokenRes.data: ${JSON.stringify(tokenRes.data, null, 2)}`)
 
       // Default return value.
       let result = {
         txid: txid,
-        valid: false
+        valid: null
       }
 
       // Build result.
@@ -1132,15 +1153,15 @@ class Slp {
       res.status(200)
       return res.json(result)
     } catch (err) {
-      wlogger.error('Error in slp.ts/validateSingle().', err)
+      wlogger.error('Error in slp.js/validateSingle().', err)
 
       return _this.errorHandler(err, res)
     }
   }
 
   /**
-   * @api {get} /slp/validateTxid2/{txid}  Validate single SLP transaction by txid.
-   * @apiName Validate single SLP transaction by txid.
+   * @api {get} /slp/validateTxid2/{txid}  Validate 2 Single
+   * @apiName Validate a single SLP transaction by txid using slp-validate.
    * @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
@@ -1199,6 +1220,284 @@ class Slp {
     }
   }
 
+  /**
+   * @api {get} /slp/whitelist SLP token whitelist.
+   * @apiName SLP token whitelist
+   * @apiGroup SLP
+   * @apiDescription Get tokens that are on the whitelist.
+   * SLPDB is typically used to validate SLP transactions. It can become unstable
+   * during periods of high network usage. A second SLPDB has been implemented
+   * that is much more stable, because it only tracks a whitelist of SLP tokens.
+   * This endpoint will return information on the SLP tokens that are included
+   * in that whitelist.
+   *
+   * For tokens on the whitelist, the /slp/validateTxid3 endpoints can be used.
+   *
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v3/slp/whitelist" -H "accept:application/json"
+   *
+   */
+  async getSlpWhitelist (req, res, next) {
+    try {
+      const list = [
+        {
+          name: 'USDH',
+          tokenId:
+            'c4b0d62156b3fa5c8f3436079b5394f7edc1bef5dc1cd2f9d0c4d46f82cca479'
+        },
+        {
+          name: 'SPICE',
+          tokenId:
+            '4de69e374a8ed21cbddd47f2338cc0f479dc58daa2bbe11cd604ca488eca0ddf'
+        },
+        {
+          name: 'PSF',
+          tokenId:
+            '38e97c5d7d3585a2cbf3f9580c82ca33985f9cb0845d4dcce220cb709f9538b0'
+        },
+        {
+          name: 'TROUT',
+          tokenId:
+            'a4fb5c2da1aa064e25018a43f9165040071d9e984ba190c222a7f59053af84b2'
+        },
+        {
+          name: 'PSFTEST',
+          tokenId:
+            'd0ef4de95b78222bfee2326ab11382f4439aa0855936e2fe6ac129a8d778baa0'
+        }
+      ]
+
+      res.status(200)
+      return res.json(list)
+    } catch (err) {
+      wlogger.error('Error in slp.ts/whitelist().', err)
+
+      return _this.errorHandler(err, res)
+    }
+  }
+
+  /**
+   * @api {get} /slp/validateTxid3/{txid}  Validate 3 Single
+   * @apiName Validate a single txid against a whitelist SLPDB
+   * @apiGroup SLP
+   * @apiDescription Alternative validation for tokens on the whitelist
+   * This endpoint is exactly the same as /slp/validateTxid/{txid} but it uses
+   * a different SLPDB. This server only indexes the SLP tokens that are on the
+   * whitelist. You can see which tokens are on the whitelist by calling the
+   * /slp/whitelist endpoint.
+   *
+   * @apiExample Example usage:
+   * curl -X GET "https://api.fullstack.cash/v3/slp/validateTxid3/f7e5199ef6669ad4d078093b3ad56e355b6ab84567e59ad0f08a5ad0244f783a" -H "accept:application/json"
+   *
+   *
+   */
+  async validate3Single (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/validate/:txid with this txid: ', txid)
+
+      const query = {
+        v: 3,
+        q: {
+          db: ['c', 'u'],
+          find: {
+            'tx.h': txid
+          },
+          limit: 300,
+          project: { 'slp.valid': 1, 'tx.h': 1, 'slp.invalidReason': 1 }
+        }
+      }
+
+      const options = _this.generateCredentials()
+
+      const s = JSON.stringify(query)
+      const b64 = Buffer.from(s).toString('base64')
+      const url = `${process.env.SLPDB_WHITELIST_URL}q/${b64}`
+      const opt = {
+        method: 'get',
+        baseURL: url,
+        headers: options.headers,
+        timeout: options.timeout
+      }
+      // Get data from SLPDB.
+      const tokenRes = await _this.axios.request(opt)
+      // console.log(`tokenRes.data: ${JSON.stringify(tokenRes.data, null, 2)}`)
+
+      // Default return value.
+      let result = {
+        txid: txid,
+        valid: null
+      }
+
+      // Build result.
+      const concatArray = tokenRes.data.c.concat(tokenRes.data.u)
+      if (concatArray.length > 0) {
+        result = {
+          txid: concatArray[0].tx.h,
+          valid: concatArray[0].slp.valid
+        }
+        if (!result.valid) {
+          result.invalidReason = concatArray[0].slp.invalidReason
+        }
+      }
+
+      res.status(200)
+      return res.json(result)
+    } catch (err) {
+      wlogger.error('Error in slp.js/validate3Single().', err)
+
+      return _this.errorHandler(err, res)
+    }
+  }
+
+  /**
+   * @api {post} /slp/validateTxid3/  Validate 3 Bulk
+   * @apiName Validate an array of TXIDs against a whitelist SLPDB
+   * @apiGroup SLP
+   * @apiDescription Alternative validation for tokens on the whitelist
+   * This endpoint is exactly the same as /slp/validateTxid but it uses
+   * a different SLPDB. This server only indexes the SLP tokens that are on the
+   * whitelist. You can see which tokens are on the whitelist by calling the
+   * /slp/whitelist endpoint.
+   *
+   * @apiExample Example usage:
+   * curl -X POST "https://api.fullstack.cash/v3/slp/validateTxid3" -H "accept:application/json" -H "Content-Type: application/json" -d '{"txids":["f7e5199ef6669ad4d078093b3ad56e355b6ab84567e59ad0f08a5ad0244f783a","fb0eeaa501a6e1acb721669c62a3f70741f48ae0fd7f4b8e1d72088785c51952"]}'
+   *
+   *
+   */
+  async validate3Bulk (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' })
+      }
+
+      // 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 slp/validate with these txids: ', txids)
+
+      const query = {
+        v: 3,
+        q: {
+          db: ['c', 'u'],
+          find: {
+            'tx.h': { $in: txids }
+          },
+          limit: 300,
+          project: { 'slp.valid': 1, 'tx.h': 1, 'slp.invalidReason': 1 }
+        }
+      }
+      const s = JSON.stringify(query)
+      const b64 = Buffer.from(s).toString('base64')
+      const url = `${process.env.SLPDB_WHITELIST_URL}q/${b64}`
+      // console.log('url: ', url)
+
+      const options = _this.generateCredentials()
+
+      // Get data from SLPDB.
+      const opt = {
+        method: 'get',
+        baseURL: url,
+        headers: options.headers,
+        timeout: options.timeout
+      }
+      const tokenRes = await _this.axios.request(opt)
+      // console.log(`tokenRes.data: ${JSON.stringify(tokenRes.data, null, 2)}`)
+
+      let formattedTokens = []
+
+      // Combine the arrays. Why? Generally there is nothing in the u array.
+      const concatArray = tokenRes.data.c.concat(tokenRes.data.u)
+
+      const tokenIds = []
+      if (concatArray.length > 0) {
+        concatArray.forEach((token) => {
+          tokenIds.push(token.tx.h) // txid
+
+          const validationResult = {
+            txid: token.tx.h,
+            valid: token.slp.valid
+          }
+
+          // If the txid is invalid, add the reason it's invalid.
+          if (!validationResult.valid) {
+            validationResult.invalidReason = token.slp.invalidReason
+          }
+
+          formattedTokens.push(validationResult)
+        })
+
+        // If a user-provided txid doesn't exist in the data, add it with
+        // valid:null property.
+        // 'null' indicates that SLPDB does not know about the transaction. It
+        // either has not seen it or has not processed it yet. A determination
+        // can not be made.
+        txids.forEach((txid) => {
+          if (!tokenIds.includes(txid)) {
+            formattedTokens.push({
+              txid: txid,
+              valid: null
+            })
+          }
+        })
+      }
+
+      // Catch a corner case of repeated txids. SLPDB will remove redundent TXIDs,
+      // which will cause the output array to be smaller than the input array.
+      if (txids.length > formattedTokens.length) {
+        const newOutput = []
+        for (let i = 0; i < txids.length; i++) {
+          const thisTxid = txids[i]
+
+          // Find the element that matches the current txid.
+          const elem = formattedTokens.filter((x) => x.txid === thisTxid)
+
+          newOutput.push(elem[0])
+        }
+
+        // Replace the original output object with the new output object.
+        formattedTokens = newOutput
+      }
+
+      // Put the output array in the same order as the input array.
+      const outAry = []
+      for (let i = 0; i < txids.length; i++) {
+        const thisTxid = txids[i]
+
+        // Need to use Array.find() because the returned output array is out
+        // of order with respect to the txid input array.
+        const output = formattedTokens.find((elem) => elem.txid === thisTxid)
+        // console.log(`output: ${JSON.stringify(output, null, 2)}`)
+
+        outAry.push(output)
+      }
+
+      res.status(200)
+      return res.json(outAry)
+    } catch (err) {
+      wlogger.error('Error in slp.js/validate3Bulk().', err)
+
+      return _this.errorHandler(err, res)
+    }
+  }
+
   /**
    * @api {get} /slp/txDetails/{txid}  SLP transaction details.
    * @apiName SLP transaction details.
@@ -1251,7 +1550,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 +1738,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
     }

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/integration/slp.js

@@ -258,4 +258,162 @@ describe('#slp', () => {
     //   )
     // })
   })
+
+  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/v3/mocks/slp-mocks.js

@@ -341,6 +341,22 @@ const mockTwoRedundentTxid = {
   u: []
 }
 
+const mockPsfToken = {
+  c: [
+    {
+      _id: '5fcaf6152898f9887902986c',
+      tx: {
+        h: 'cdfed769ef7b69e09be06d2821b88598d9a5d711b8f9bd369763c78b7a578fbc'
+      },
+      slp: {
+        valid: true,
+        invalidReason: null
+      }
+    }
+  ],
+  u: []
+}
+
 const mockTxHistory = [
   {
     tx: {
@@ -526,6 +542,78 @@ const mockTxHistory = [
   }
 ]
 
+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,
@@ -541,5 +629,8 @@ module.exports = {
   mockSingleValidTxid,
   mockTwoValidTxid,
   mockTwoRedundentTxid,
-  mockTxHistory
+  mockTxHistory,
+  mockPsfToken,
+  mockValidateBulk,
+  mockValidate3Bulk
 }

test/v3/slp.js

@@ -338,7 +338,231 @@ describe('#SLP', () => {
     }
   })
 
-  describe('validateBulk()', () => {
+  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('#validateSingle', () => {
+    it('should throw 400 if txid is empty', async () => {
+      req.params.txid = ''
+      const result = await slpRoute.validateSingle(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: {
+            c: [],
+            u: []
+          }
+        })
+      }
+
+      const txid =
+        'f7e5199ef6669ad4d078093b3ad56e355b6ab84567e59ad0f08a5ad0244f783a'
+
+      req.params.txid = txid
+      const result = await slpRoute.validateSingle(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.equal(result.txid, txid)
+      assert.equal(result.valid, null)
+    })
+
+    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: mockData.mockSingleValidTxid })
+      }
+
+      const txid =
+        '77872738b6bddee6c0cbdb9509603de20b15d4f6b26602f629417aec2f5d5e8d'
+
+      req.params.txid = txid
+      const result = await slpRoute.validateSingle(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.equal(result.txid, txid)
+      assert.equal(result.valid, true)
+    })
+
+    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.validateSingle(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('#validate3Single', () => {
+    it('should throw 400 if txid is empty', async () => {
+      req.params.txid = ''
+      const result = await slpRoute.validate3Single(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: {
+            c: [],
+            u: []
+          }
+        })
+      }
+
+      const txid =
+        'f7e5199ef6669ad4d078093b3ad56e355b6ab84567e59ad0f08a5ad0244f783a'
+
+      req.params.txid = txid
+      const result = await slpRoute.validate3Single(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.equal(result.txid, txid)
+      assert.equal(result.valid, null)
+    })
+
+    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: mockData.mockSingleValidTxid })
+      }
+
+      const txid =
+        'cdfed769ef7b69e09be06d2821b88598d9a5d711b8f9bd369763c78b7a578fbc'
+
+      req.params.txid = txid
+      const result = await slpRoute.validate3Single(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      // assert.equal(result.txid, txid)
+      assert.equal(result.valid, true)
+    })
+
+    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.validate3Single(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()', () => {
     const validateBulk = slpRoute.validateBulk
 
     it('should throw 400 if txid array is empty', async () => {
@@ -461,77 +685,272 @@ describe('#SLP', () => {
       assert.hasAllKeys(result[0], ['txid', 'valid'])
       assert.equal(result.length, 2)
     })
+
+    it('should handle a mix of valid, invalid, and non-SLP txs', async () => {
+      // Mock the RPC call for unit tests.
+      if (process.env.TEST === 'unit') {
+        sandbox.stub(slpRoute.axios, 'request').resolves({
+          data: mockData.mockValidateBulk
+        })
+      }
+
+      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 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('#validate2Single', () => {
-    it('should throw 400 if txid is empty', async () => {
-      req.params.txid = ''
-      const result = await slpRoute.validate2Single(req, res)
+  describe('#validate3Bulk', () => {
+    const validate3Bulk = slpRoute.validate3Bulk
+
+    it('should throw 400 if txid array is empty', async () => {
+      const result = await validate3Bulk(req, res)
       // console.log(`result: ${util.inspect(result)}`)
 
       assert.hasAllKeys(result, ['error'])
-      assert.include(result.error, 'txid can not be empty')
+      assert.include(result.error, 'txids needs to be an array')
+      assert.equal(res.statusCode, 400)
     })
 
-    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 } })
-      }
+    it('should throw 400 error if array is too large', async () => {
+      const testArray = []
+      for (var i = 0; i < 25; i++) testArray.push('')
 
-      const txid =
-        'f7e5199ef6669ad4d078093b3ad56e355b6ab84567e59ad0f08a5ad0244f783a'
+      req.body.txids = testArray
 
-      req.params.txid = txid
-      const result = await slpRoute.validate2Single(req, res)
+      const result = await validate3Bulk(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      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' })
+
+      req.body.txids = [
+        '77872738b6bddee6c0cbdb9509603de20b15d4f6b26602f629417aec2f5d5e8d'
+      ]
+      const result = await validate3Bulk(req, res)
       // console.log(`result: ${JSON.stringify(result, null, 2)}`)
 
-      assert.equal(result.txid, txid)
-      assert.equal(result.isValid, false)
+      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 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 } })
-      }
+    it('returns proper error when downstream service is down', async () => {
+      // Mock the timeout error.
+      sandbox.stub(slpRoute.axios, 'request').throws({ code: 'ECONNREFUSED' })
 
-      const txid =
-        '3a4b628cbcc183ab376d44ce5252325f042268307ffa4a53443e92b6d24fb488'
-
-      req.params.txid = txid
-      const result = await slpRoute.validate2Single(req, res)
+      req.body.txids = [
+        '77872738b6bddee6c0cbdb9509603de20b15d4f6b26602f629417aec2f5d5e8d'
+      ]
+      const result = await validate3Bulk(req, res)
       // console.log(`result: ${JSON.stringify(result, null, 2)}`)
 
-      assert.equal(result.txid, txid)
-      assert.equal(result.isValid, true)
+      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 validate array with single element', async () => {
+      // Mock the RPC call for unit tests.
+      if (process.env.TEST === 'unit') {
+        sandbox.stub(slpRoute.axios, 'request').resolves({
+          data: mockData.mockPsfToken
+        })
+      }
+
+      req.body.txids = [
+        'cdfed769ef7b69e09be06d2821b88598d9a5d711b8f9bd369763c78b7a578fbc'
+      ]
+
+      const result = await validate3Bulk(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.isArray(result)
+      assert.hasAllKeys(result[0], ['txid', 'valid'])
+    })
+
+    it('should validate array with two elements', async () => {
+      // Mock the RPC call for unit tests.
+      if (process.env.TEST === 'unit') {
+        sandbox.stub(slpRoute.axios, 'request').resolves({
+          data: mockData.mockPsfToken
+        })
+      }
+
+      req.body.txids = [
+        'cdfed769ef7b69e09be06d2821b88598d9a5d711b8f9bd369763c78b7a578fbc',
+        'cdfed769ef7b69e09be06d2821b88598d9a5d711b8f9bd369763c78b7a578fbc'
+      ]
+
+      const result = await validate3Bulk(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.isArray(result)
+      assert.hasAllKeys(result[0], ['txid', 'valid'])
+      assert.equal(result.length, 2)
+    })
+
+    // Captures a regression bug that went out to production, captured in this
+    // GitHub Issue: https://github.com/Bitcoin-com/rest.bitcoin.com/issues/518
+    it('should return two elements if given two elements', async () => {
+      // Mock the RPC call for unit tests.
+      if (process.env.TEST === 'unit') {
+        sandbox.stub(slpRoute.axios, 'request').resolves({
+          data: mockData.mockPsfToken
+        })
+      }
+
+      req.body.txids = [
+        'cdfed769ef7b69e09be06d2821b88598d9a5d711b8f9bd369763c78b7a578fbc',
+        'cdfed769ef7b69e09be06d2821b88598d9a5d711b8f9bd369763c78b7a578fbc'
+      ]
+
+      const result = await validate3Bulk(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.isArray(result)
+      assert.hasAllKeys(result[0], ['txid', 'valid'])
+      assert.equal(result.length, 2)
     })
 
-    // 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'
+      // This is a unit-test only test, as the results change depending on if
+      // its tested against the BCHN or ABC networks. There are integration tests
+      // for this test case in the ../integration/slp.js file.
+      it('should handle a mix of valid, invalid, and non-SLP txs', async () => {
+        // Mock the RPC call for unit tests.
+
+        sandbox.stub(slpRoute.axios, 'request').resolves({
+          data: mockData.mockValidate3Bulk
         })
 
-        const txid =
-          'eacb1085dfa296fef6d4ae2c0f4529a1bef096dd2325bdcc6dcb5241b3bdb579'
+        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.params.txid = txid
-        const result = await slpRoute.validate2Single(req, res)
+        req.body.txids = txids
+        const result = await validate3Bulk(req, res)
         // console.log(`result: ${JSON.stringify(result, null, 2)}`)
 
-        assert.isAbove(res.statusCode, 499, 'HTTP status code 503 expected.')
+        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)
+
+        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.error,
-          'Could not communicate with full node',
-          'Error message expected'
+          result[6].invalidReason,
+          'Token outputs are greater than valid token inputs'
         )
       })
     }