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

fix(tokenUtxoDetails): Renabling local caching of tx validation

package.json

@@ -12,11 +12,12 @@
     "test:integration": "npm run test:integration:bchn",
     "test:integration:abc": "export RESTURL=https://abc.fullstack.cash/v4/ && export IS_USING_FREE_TIER=true && mocha --timeout 30000 test/integration/ && mocha --timeout 30000 test/integration/chains/abc/",
     "test:integration:bchn": "export RESTURL=https://bchn.fullstack.cash/v4/ && export IS_USING_FREE_TIER=true && mocha --timeout 30000 test/integration/ && mocha --timeout 30000 test/integration/chains/bchn/",
-    "test:integration:testnet": "IS_USING_FREE_TIER=true mocha --timeout 30000 test/integration/testnet/",
+    "test:integration:testnet": "IS_USING_FREE_TIER=true mocha --timeout 30000 test/integration/chains/testnet/",
     "test:integration:local": "RESTURL=http://localhost:3000/v4/ mocha --timeout 30000 test/integration",
     "test:integration:local:bchn": "RESTURL=http://localhost:3000/v4/ bash test/integration/test-bchn-integration.sh",
     "test:integration:local:testnet": "RESTURL=http://localhost:4000/v4/ mocha --timeout 30000 test/integration/testnet",
-    "test:temp": "export RESTURL=http://localhost:3000/v4/ && export IS_USING_FREE_TIER=true && mocha --timeout 30000 test/integration/chains/bchn/",
+    "test:temp": "export RESTURL=http://localhost:3000/v4/ && mocha --timeout 30000 -g '#tokenUtxoDetails' test/integration/",
+    "test:temp2": "mocha --timeout 30000 -g '#tokenUtxoDetails' test/unit/",
     "coverage": "nyc report --reporter=text-lcov | coveralls",
     "coverage:report": "nyc --reporter=html mocha --timeout 25000 test/unit/",
     "docs": "./node_modules/.bin/apidoc -i src/ -o docs"

src/slp/utils.js

@@ -431,10 +431,14 @@ class Utils {
    *     '00ea27261196a411776f81029c0ebe34362936b4a9847deb1f7a40a02b3a1476',
    *    valid: true } ]
    */
+  // This function has two responses. If SLPDB is working correctly, the output
+  // will be like the examples above. If SLPDB has fallen behind real-time
+  // processing, it will return this output:
+  // [ null ]
   async validateTxid(txid) {
     const path = `${this.restURL}slp/validateTxid`
 
-    // console.log(`txid: ${JSON.stringify(txid, null, 2)}`)
+    console.log(`txid: ${JSON.stringify(txid, null, 2)}`)
 
     // Handle a single TXID or an array of TXIDs.
     let txids
@@ -449,7 +453,9 @@ class Utils {
         },
         _this.axiosOptions
       )
-      // console.log(`response.data: ${JSON.stringify(response.data, null, 2)}`)
+      // console.log(
+      //   `validateTxid response.data: ${JSON.stringify(response.data, null, 2)}`
+      // )
 
       const validatedTxids = response.data
 
@@ -1288,19 +1294,53 @@ class Utils {
           // property. i.e. it has been successfully hydrated with SLP
           // information.
 
+          // CT 12/13/2020: Disabling the cache until I get processing of tokens
+          // to be more stable.
           // If the value has been cached, use the cached version first.
           let isValid = cachedTxValidation[utxo.txid]
+          if (!isValid) isValid = null
+          // let isValid = null
+
+          // There are two possible responses from SLPDB. If SLPDB is functioning
+          // correctly, then validateTxid() will return this:
+          // isValid: [
+          //   {
+          // 	"txid": "ff0c0354f8d3ddb34fa36f73494eb58ea24f8b8da6904aa8ed43b7a74886c583",
+          // 	"valid": true
+          //   }
+          // ]
+          //
+          // If SLPDB has fallen behind real-time processing, it will return this:
+          // isValid: [
+          //   null
+          // ]
+          //
+          // Note: validateTxid3() has the same output as validateTxid().
+          // validateTxid2() uses slp-validate, which has a different output format.
 
           // If not in the cache, try the general SLPDB.
-          if (isValid == null) {
+          if (isValid === null) {
+            // console.log(`utxo: ${JSON.stringify(utxo, null, 2)}`)
             isValid = await this.validateTxid(utxo.txid)
+            // console.log(
+            //   `validateTxid() isValid: ${JSON.stringify(isValid, null, 2)}`
+            // )
+
+            // Handle corner case where SLPDB returns an array with a null element.
+            if (isValid[0] === null)
+              isValid = [{ txid: utxo.txid, valid: null }]
+
             isValid = isValid[0].valid
 
             // Save the result to the local cache.
-            cachedTxValidation[utxo.txid] = isValid
+            // cachedTxValidation[utxo.txid] = isValid
           }
           // console.log(`isValid: ${JSON.stringify(isValid, null, 2)}`)
 
+          // console.log(
+          //   `pre-validateTxid3() isValid: ${JSON.stringify(isValid, null, 2)}`
+          // )
+
           // If still null, check the whitelist SLPDB
           if (isValid === null) {
             // console.log(
@@ -1334,28 +1374,40 @@ class Utils {
               //   )}`
               // )
 
-              isValid = isValid[0].valid
+              if (isValid[0] !== null) isValid = isValid[0].valid
 
               // Save the result to the local cache.
-              cachedTxValidation[utxo.txid] = isValid
+              // cachedTxValidation[utxo.txid] = isValid
             }
           }
 
+          // console.log(
+          //   `pre-validateTxid2() isValid: ${JSON.stringify(isValid, null, 2)}`
+          // )
+
           // If still null, as a last resort, check it against slp-validate
           if (isValid === null) {
-            isValid = await this.validateTxid2(utxo.txid)
+            try {
+              isValid = await this.validateTxid2(utxo.txid)
+            } catch (err) {
+              // Mark as invalid if validateTxid2() throws an error.
+              isValid = null
+            }
             // console.log(
             //   `slp-validate isValid: ${JSON.stringify(isValid, null, 2)}`
             // )
 
-            isValid = isValid.isValid
+            if (isValid !== null) isValid = isValid.isValid
 
             // Save the result to the local cache.
-            cachedTxValidation[utxo.txid] = isValid
+            // cachedTxValidation[utxo.txid] = isValid
           }
 
           // console.log(`isValid: ${JSON.stringify(isValid, null, 2)}`)
           outAry[i].isValid = isValid
+
+          // Save the txid to the local cache to reduce API calls.
+          cachedTxValidation[utxo.txid] = isValid
         }
       }
 

test/integration/chains/testnet/blockbook.js

@@ -1,186 +0,0 @@
-/*
-  Integration tests for the Blockbook library.
-
-*/
-
-const chai = require("chai")
-const assert = chai.assert
-
-const RESTURL = process.env.RESTURL
-  ? process.env.RESTURL
-  : `https://testnet3.fullstack.cash/v4/`
-// if (process.env.RESTURL) RESTURL = process.env.RESTURL
-
-const BCHJS = require("../../../src/bch-js")
-// const bchjs = new BCHJS({ restURL: `https://testnet.bchjs.cash/v4/` })
-const bchjs = new BCHJS({ restURL: RESTURL, apiToken: process.env.BCHJSTOKEN })
-// const bchjs = new BCHJS({ restURL: RESTURL })
-//const axios = require("axios")
-
-// Inspect utility used for debugging.
-const util = require("util")
-util.inspect.defaultOptions = {
-  showHidden: true,
-  colors: true,
-  depth: 3
-}
-
-describe(`#Blockbook`, () => {
-  beforeEach(async () => {
-    if (process.env.IS_USING_FREE_TIER) await sleep(1000)
-  })
-
-  describe(`#Balance`, () => {
-    it(`should GET balance for a single address`, async () => {
-      const addr = "bchtest:qrvn2n228aa39xupcw9jw0d3fj8axxky656e4j62z2"
-
-      const result = await bchjs.Blockbook.balance(addr)
-      // console.log(`result: ${util.inspect(result)}`)
-
-      assert.hasAnyKeys(result, [
-        "page",
-        "totalPages",
-        "itemsOnPage",
-        "address",
-        "balance",
-        "totalReceived",
-        "totalSent",
-        "unconfirmedBalance",
-        "unconfirmedTxs",
-        "txs",
-        "txids"
-      ])
-      assert.isArray(result.txids)
-    })
-
-    it(`should POST request balances for an array of addresses`, async () => {
-      const addr = [
-        "bchtest:qrvn2n228aa39xupcw9jw0d3fj8axxky656e4j62z2",
-        "bchtest:qrvn2n228aa39xupcw9jw0d3fj8axxky656e4j62z2"
-      ]
-
-      const result = await bchjs.Blockbook.balance(addr)
-      //console.log(`result: ${util.inspect(result)}`)
-
-      assert.isArray(result)
-      assert.hasAnyKeys(result[0], [
-        "page",
-        "totalPages",
-        "itemsOnPage",
-        "address",
-        "balance",
-        "totalReceived",
-        "totalSent",
-        "unconfirmedBalance",
-        "unconfirmedTxs",
-        "txs",
-        "txids"
-      ])
-      assert.isArray(result[0].txids)
-    })
-
-    it(`should throw an error for improper input`, async () => {
-      try {
-        const addr = 12345
-
-        await bchjs.Blockbook.balance(addr)
-        assert.equal(true, false, "Unexpected result!")
-      } catch (err) {
-        //console.log(`err: `, err)
-        assert.include(
-          err.message,
-          `Input address must be a string or array of strings`
-        )
-      }
-    })
-
-    it(`should throw error on array size rate limit`, async () => {
-      try {
-        const addr = []
-        for (let i = 0; i < 25; i++)
-          addr.push("bchtest:qrvn2n228aa39xupcw9jw0d3fj8axxky656e4j62z2")
-
-        const result = await bchjs.Blockbook.balance(addr)
-
-        console.log(`result: ${util.inspect(result)}`)
-        assert.equal(true, false, "Unexpected result!")
-      } catch (err) {
-        assert.hasAnyKeys(err, ["error"])
-        assert.include(err.error, "Array too large")
-      }
-    })
-  })
-
-  describe(`#utxo`, () => {
-    it(`should GET utxos for a single address`, async () => {
-      const addr = "bchtest:qrvn2n228aa39xupcw9jw0d3fj8axxky656e4j62z2"
-
-      const result = await bchjs.Blockbook.utxo(addr)
-      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
-
-      assert.isArray(result)
-      assert.hasAnyKeys(result[0], [
-        "txid",
-        "vout",
-        "value",
-        "height",
-        "confirmations"
-      ])
-    })
-
-    it(`should POST utxo details for an array of addresses`, async () => {
-      const addr = [
-        "bchtest:qrvn2n228aa39xupcw9jw0d3fj8axxky656e4j62z2",
-        "bchtest:qrvn2n228aa39xupcw9jw0d3fj8axxky656e4j62z2"
-      ]
-
-      const result = await bchjs.Blockbook.utxo(addr)
-      //console.log(`result: ${JSON.stringify(result, null, 2)}`)
-
-      assert.isArray(result)
-      assert.isArray(result[0])
-      assert.hasAnyKeys(result[0][0], [
-        "txid",
-        "vout",
-        "value",
-        "height",
-        "confirmations"
-      ])
-    })
-
-    it(`should throw an error for improper input`, async () => {
-      try {
-        const addr = 12345
-
-        await bchjs.Blockbook.utxo(addr)
-        assert.equal(true, false, "Unexpected result!")
-      } catch (err) {
-        //console.log(`err: `, err)
-        assert.include(
-          err.message,
-          `Input address must be a string or array of strings`
-        )
-      }
-    })
-
-    it(`should throw error on array size rate limit`, async () => {
-      try {
-        const addr = []
-        for (let i = 0; i < 25; i++)
-          addr.push("bchtest:qrvn2n228aa39xupcw9jw0d3fj8axxky656e4j62z2")
-
-        await bchjs.Blockbook.utxo(addr)
-        //console.log(`result: ${util.inspect(result)}`)
-
-        assert.equal(true, false, "Unexpected result!")
-      } catch (err) {
-        assert.hasAnyKeys(err, ["error"])
-        assert.include(err.error, "Array too large")
-      }
-    })
-  })
-})
-
-function sleep(ms) {
-  return new Promise(resolve => setTimeout(resolve, ms))
-}

test/integration/chains/testnet/blockchain.js

@@ -15,7 +15,7 @@ const RESTURL = process.env.RESTURL
   : "https://testnet3.fullstack.cash/v4/"
 // if (process.env.RESTURL) RESTURL = process.env.RESTURL
 
-const BCHJS = require("../../../src/bch-js")
+const BCHJS = require("../../../../src/bch-js")
 // const bchjs = new BCHJS({ restURL: `https://testnet.bchjs.cash/v4/` })
 const bchjs = new BCHJS({ restURL: RESTURL, apiToken: process.env.BCHJSTOKEN })
 

test/integration/chains/testnet/control.js

@@ -9,7 +9,7 @@ const RESTURL = process.env.RESTURL
   ? process.env.RESTURL
   : `https://testnet3.fullstack.cash/v4/`
 
-const BCHJS = require("../../../src/bch-js")
+const BCHJS = require("../../../../src/bch-js")
 const bchjs = new BCHJS({ restURL: RESTURL, apiToken: process.env.BCHJSTOKEN })
 
 describe(`#control`, () => {

test/integration/chains/testnet/electrumx.js

@@ -6,7 +6,7 @@ const RESTURL = process.env.RESTURL
   ? process.env.RESTURL
   : `https://testnet3.fullstack.cash/v4/`
 
-const BCHJS = require("../../../src/bch-js")
+const BCHJS = require("../../../../src/bch-js")
 const bchjs = new BCHJS({ restURL: RESTURL, apiToken: process.env.BCHJSTOKEN })
 
 describe(`#ElectrumX`, () => {

test/integration/chains/testnet/ninsight.js

@@ -2,7 +2,7 @@ const chai = require("chai")
 const assert = chai.assert
 const sinon = require("sinon")
 
-const BCHJS = require("../../../src/bch-js")
+const BCHJS = require("../../../../src/bch-js")
 const bchjs = new BCHJS({ ninsightURL: "https://trest.bitcoin.com/v2" })
 
 describe(`#Ninsight`, () => {
@@ -105,7 +105,8 @@ describe(`#Ninsight`, () => {
   })
   describe(`#txDetails`, () => {
     it(`should POST transactions details for a single address`, async () => {
-      const txid = "76856d82e00b2696acd8d989e1fa6c46b431005046a285ce905814cac0ff8fea"
+      const txid =
+        "76856d82e00b2696acd8d989e1fa6c46b431005046a285ce905814cac0ff8fea"
 
       const result = await bchjs.Ninsight.txDetails(txid)
       // console.log(`result: ${JSON.stringify(result, null, 2)}`)

test/integration/chains/testnet/rawtransaction.js

@@ -13,7 +13,7 @@ const RESTURL = process.env.RESTURL
   : `https://testnet3.fullstack.cash/v4/`
 // if (process.env.RESTURL) RESTURL = process.env.RESTURL
 
-const BCHJS = require("../../../src/bch-js")
+const BCHJS = require("../../../../src/bch-js")
 // const bchjs = new BCHJS({ restURL: `https://testnet.bchjs.cash/v4/` })
 const bchjs = new BCHJS({ restURL: RESTURL, apiToken: process.env.BCHJSTOKEN })
 
@@ -251,7 +251,7 @@ describe("#rawtransaction", () => {
         //console.log(`err: ${util.inspect(err)}`)
 
         assert.hasAllKeys(err, ["error"])
-        assert.include(err.error, "bad-txns-inputs-missingorspent (code 16)")
+        assert.include(err.error, "Missing inputs")
       }
     })
 
@@ -268,7 +268,7 @@ describe("#rawtransaction", () => {
         // console.log(`err: ${util.inspect(err)}`)
 
         assert.hasAllKeys(err, ["error"])
-        assert.include(err.error, "bad-txns-inputs-missingorspent (code 16)")
+        assert.include(err.error, "Missing inputs")
       }
     })
 

test/integration/chains/testnet/slp.js

@@ -10,7 +10,7 @@ const RESTURL = process.env.RESTURL
   : `https://testnet3.fullstack.cash/v4/`
 // if (process.env.RESTURL) RESTURL = process.env.RESTURL
 
-const BCHJS = require("../../../src/bch-js")
+const BCHJS = require("../../../../src/bch-js")
 // const bchjs = new BCHJS({ restURL: `https://testnet.bchjs.cash/v4/` })
 const bchjs = new BCHJS({ restURL: RESTURL, apiToken: process.env.BCHJSTOKEN })
 

test/integration/chains/testnet/util.js

@@ -11,7 +11,7 @@ const RESTURL = process.env.RESTURL
   : `https://testnet3.fullstack.cash/v4/`
 // if (process.env.RESTURL) RESTURL = process.env.RESTURL
 
-const BCHJS = require("../../../src/bch-js")
+const BCHJS = require("../../../../src/bch-js")
 // const bchjs = new BCHJS({ restURL: `https://testnet.bchjs.cash/v4/` })
 const bchjs = new BCHJS({ restURL: RESTURL, apiToken: process.env.BCHJSTOKEN })
 

test/integration/implementations/sweet/rawtransaction.js

@@ -0,0 +1,71 @@
+/*
+  Integration tests for the bchjs. Only covers calls made to
+  rest.bitcoin.com.
+
+  TODO
+*/
+
+const chai = require("chai")
+const assert = chai.assert
+const BCHJS = require("../../../../src/bch-js")
+const bchjs = new BCHJS()
+
+// Inspect utility used for debugging.
+const util = require("util")
+util.inspect.defaultOptions = {
+  showHidden: true,
+  colors: true,
+  depth: 3
+}
+
+describe("#rawtransaction", () => {
+  beforeEach(async () => {
+    if (process.env.IS_USING_FREE_TIER) await sleep(1000)
+  })
+
+  /*
+    Testing sentRawTransaction isn't really possible with an integration test,
+    as the endpoint really needs an e2e test to be properly tested. The tests
+    below expect error messages returned from the server, but at least test
+    that the server is responding on those endpoints, and responds consistently.
+  */
+  describe("sendRawTransaction", () => {
+    it("should send a single transaction hex", async () => {
+      try {
+        const hex =
+          "01000000013ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a000000006a4730440220540986d1c58d6e76f8f05501c520c38ce55393d0ed7ed3c3a82c69af04221232022058ea43ed6c05fec0eccce749a63332ed4525460105346f11108b9c26df93cd72012103083dfc5a0254613941ddc91af39ff90cd711cdcde03a87b144b883b524660c39ffffffff01807c814a000000001976a914d7e7c4e0b70eaa67ceff9d2823d1bbb9f6df9a5188ac00000000"
+
+        await bchjs.RawTransactions.sendRawTransaction(hex)
+        //console.log(`result ${JSON.stringify(result, null, 2)}`)
+
+        assert.equal(true, false, "Unexpected result!")
+      } catch (err) {
+        //console.log(`err: ${util.inspect(err)}`)
+
+        assert.hasAllKeys(err, ["error"])
+        assert.include(err.error, "Missing inputs")
+      }
+    })
+
+    it("should send an array of tx hexes", async () => {
+      try {
+        const hexes = [
+          "01000000013ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a000000006a4730440220540986d1c58d6e76f8f05501c520c38ce55393d0ed7ed3c3a82c69af04221232022058ea43ed6c05fec0eccce749a63332ed4525460105346f11108b9c26df93cd72012103083dfc5a0254613941ddc91af39ff90cd711cdcde03a87b144b883b524660c39ffffffff01807c814a000000001976a914d7e7c4e0b70eaa67ceff9d2823d1bbb9f6df9a5188ac00000000",
+          "01000000013ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a000000006a4730440220540986d1c58d6e76f8f05501c520c38ce55393d0ed7ed3c3a82c69af04221232022058ea43ed6c05fec0eccce749a63332ed4525460105346f11108b9c26df93cd72012103083dfc5a0254613941ddc91af39ff90cd711cdcde03a87b144b883b524660c39ffffffff01807c814a000000001976a914d7e7c4e0b70eaa67ceff9d2823d1bbb9f6df9a5188ac00000000"
+        ]
+
+        const result = await bchjs.RawTransactions.sendRawTransaction(hexes)
+        console.log(`result ${JSON.stringify(result, null, 2)}`)
+      } catch (err) {
+        // console.log(`err: ${util.inspect(err)}`)
+
+        assert.hasAllKeys(err, ["error"])
+        assert.include(err.error, "Missing inputs")
+      }
+    })
+  })
+})
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}

test/integration/implementations/sweet/slp.js

@@ -0,0 +1,246 @@
+/*
+  Integration tests for the bchjs covering SLP tokens.
+  These tests are specific to the ABC chain.
+*/
+
+const chai = require("chai")
+const assert = chai.assert
+
+const BCHJS = require("../../../../src/bch-js")
+let bchjs
+
+// Inspect utility used for debugging.
+const util = require("util")
+util.inspect.defaultOptions = {
+  showHidden: true,
+  colors: true,
+  depth: 1
+}
+
+describe(`#SLP`, () => {
+  // before(() => {
+  //   console.log(`bchjs.SLP.restURL: ${bchjs.SLP.restURL}`)
+  //   console.log(`bchjs.SLP.apiToken: ${bchjs.SLP.apiToken}`)
+  // })
+
+  beforeEach(async () => {
+    // Introduce a delay so that the BVT doesn't trip the rate limits.
+    if (process.env.IS_USING_FREE_TIER) await sleep(1000)
+
+    bchjs = new BCHJS()
+  })
+
+  describe("#util", () => {
+    describe("#tokenUtxoDetails", () => {
+      it("should handle a range of UTXO types", async () => {
+        const utxos = [
+          // Malformed SLP tx
+          {
+            note: "Malformed SLP tx",
+            tx_hash:
+              "f7e5199ef6669ad4d078093b3ad56e355b6ab84567e59ad0f08a5ad0244f783a",
+            tx_pos: 1,
+            value: 546
+          },
+          // Normal TX (non-SLP)
+          {
+            note: "Normal TX (non-SLP)",
+            tx_hash:
+              "01cdaec2f8b311fc2d6ecc930247bd45fa696dc204ab684596e281fe1b06c1f0",
+            tx_pos: 0,
+            value: 400000
+          },
+          // Valid PSF SLP tx
+          {
+            note: "Valid PSF SLP tx",
+            tx_hash:
+              "daf4d8b8045e7a90b7af81bfe2370178f687da0e545511bce1c9ae539eba5ffd",
+            tx_pos: 1,
+            value: 546
+          },
+          // Valid SLP token not in whitelist
+          {
+            note: "Valid SLP token not in whitelist",
+            tx_hash:
+              "3a4b628cbcc183ab376d44ce5252325f042268307ffa4a53443e92b6d24fb488",
+            tx_pos: 1,
+            value: 546
+          },
+          // Token send on BCHN network.
+          {
+            note: "Token send on BCHN network",
+            tx_hash:
+              "402c663379d9699b6e2dd38737061e5888c5a49fca77c97ab98e79e08959e019",
+            tx_pos: 1,
+            value: 546
+          },
+          // Token send on ABC network.
+          {
+            note: "Token send on ABC network",
+            tx_hash:
+              "336bfe2168aac4c3303508a9e8548a0d33797a83b85b76a12d845c8d6674f79d",
+            tx_pos: 1,
+            value: 546
+          },
+          // Known invalid SLP token send of PSF tokens.
+          {
+            note: "Known invalid SLP token send of PSF tokens",
+            tx_hash:
+              "2bf691ad3679d928fef880b8a45b93b233f8fa0d0a92cf792313dbe77b1deb74",
+            tx_pos: 1,
+            value: 546
+          }
+        ]
+
+        const data = await bchjs.SLP.Utils.tokenUtxoDetails(utxos)
+        // console.log(`data: ${JSON.stringify(data, null, 2)}`)
+
+        // Malformed SLP tx
+        assert.equal(data[0].tx_hash, utxos[0].tx_hash)
+        assert.equal(data[0].isValid, false)
+
+        // Normal TX (non-SLP)
+        assert.equal(data[1].tx_hash, utxos[1].tx_hash)
+        assert.equal(data[1].isValid, false)
+
+        // Valid PSF SLP tx
+        assert.equal(data[2].tx_hash, utxos[2].tx_hash)
+        assert.equal(data[2].isValid, true)
+
+        // Valid SLP token not in whitelist
+        assert.equal(data[3].tx_hash, utxos[3].tx_hash)
+        assert.equal(data[3].isValid, true)
+
+        // Token send on BCHN network
+        assert.equal(data[4].tx_hash, utxos[4].tx_hash)
+        assert.equal(data[4].isValid, true)
+
+        // Token send on ABC network
+        assert.equal(data[5].tx_hash, utxos[5].tx_hash)
+        assert.equal(data[5].isValid, null)
+
+        // Known invalid SLP token send of PSF tokens
+        assert.equal(data[6].tx_hash, utxos[6].tx_hash)
+        assert.equal(data[6].isValid, false)
+      })
+    })
+
+    describe("#validateTxid3", () => {
+      it("should invalidate a known invalid TXID", async () => {
+        const txid =
+          "f7e5199ef6669ad4d078093b3ad56e355b6ab84567e59ad0f08a5ad0244f783a"
+
+        const result = await bchjs.SLP.Utils.validateTxid3(txid)
+        // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+        assert.isArray(result)
+
+        assert.property(result[0], "txid")
+        assert.equal(result[0].txid, txid)
+
+        assert.property(result[0], "valid")
+        assert.equal(result[0].valid, null)
+      })
+
+      it("should validate a known valid TXID", async () => {
+        const txid =
+          "daf4d8b8045e7a90b7af81bfe2370178f687da0e545511bce1c9ae539eba5ffd"
+
+        const result = await bchjs.SLP.Utils.validateTxid3(txid)
+        // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+        assert.isArray(result)
+
+        assert.property(result[0], "txid")
+        assert.equal(result[0].txid, txid)
+
+        assert.property(result[0], "valid")
+        assert.equal(result[0].valid, true)
+      })
+
+      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",
+          // Unprocessed SLP TX
+          "402c663379d9699b6e2dd38737061e5888c5a49fca77c97ab98e79e08959e019"
+        ]
+
+        const result = await bchjs.SLP.Utils.validateTxid3(txids)
+        // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+        assert.isArray(result)
+
+        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)
+
+        // True in validateTxid()
+        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, true)
+      })
+    })
+
+    describe("#validateTxid", () => {
+      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"
+        ]
+
+        const result = await bchjs.SLP.Utils.validateTxid(txids)
+        // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+        assert.isArray(result)
+
+        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)
+
+        // True in validateTxid() but null in validateTxid3()
+        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, true)
+
+        assert.equal(result[5].txid, txids[5])
+        assert.equal(result[5].valid, null)
+      })
+    })
+  })
+})
+
+// Promise-based sleep function
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}

test/integration/slp.js

@@ -464,97 +464,27 @@ describe(`#SLP`, () => {
         assert.equal(data[0].isValid, false)
       })
 
-      // it("should handle a range of UTXO types", async () => {
-      //   const utxos = [
-      //     // Malformed SLP tx
-      //     {
-      //       note: "Malformed SLP tx",
-      //       tx_hash:
-      //         "f7e5199ef6669ad4d078093b3ad56e355b6ab84567e59ad0f08a5ad0244f783a",
-      //       tx_pos: 1,
-      //       value: 546
-      //     },
-      //     // Normal TX (non-SLP)
-      //     {
-      //       note: "Normal TX (non-SLP)",
-      //       tx_hash:
-      //         "01cdaec2f8b311fc2d6ecc930247bd45fa696dc204ab684596e281fe1b06c1f0",
-      //       tx_pos: 0,
-      //       value: 400000
-      //     },
-      //     // Valid PSF SLP tx
-      //     {
-      //       note: "Valid PSF SLP tx",
-      //       tx_hash:
-      //         "daf4d8b8045e7a90b7af81bfe2370178f687da0e545511bce1c9ae539eba5ffd",
-      //       tx_pos: 1,
-      //       value: 546
-      //     },
-      //     // Valid SLP token not in whitelist
-      //     {
-      //       note: "Valid SLP token not in whitelist",
-      //       tx_hash:
-      //         "3a4b628cbcc183ab376d44ce5252325f042268307ffa4a53443e92b6d24fb488",
-      //       tx_pos: 1,
-      //       value: 546
-      //     },
-      //     // Token send on BCHN network.
-      //     {
-      //       note: "Token send on BCHN network",
-      //       tx_hash:
-      //         "402c663379d9699b6e2dd38737061e5888c5a49fca77c97ab98e79e08959e019",
-      //       tx_pos: 1,
-      //       value: 546
-      //     },
-      //     // Token send on ABC network.
-      //     {
-      //       note: "Token send on ABC network",
-      //       tx_hash:
-      //         "336bfe2168aac4c3303508a9e8548a0d33797a83b85b76a12d845c8d6674f79d",
-      //       tx_pos: 1,
-      //       value: 546
-      //     },
-      //     // Known invalid SLP token send of PSF tokens.
-      //     {
-      //       note: "Known invalid SLP token send of PSF tokens",
-      //       tx_hash:
-      //         "2bf691ad3679d928fef880b8a45b93b233f8fa0d0a92cf792313dbe77b1deb74",
-      //       tx_pos: 1,
-      //       value: 546
-      //     }
-      //   ]
-      //
-      //   const data = await bchjs.SLP.Utils.tokenUtxoDetails(utxos)
-      //   // console.log(`data: ${JSON.stringify(data, null, 2)}`)
-      //
-      //   // Malformed SLP tx
-      //   assert.equal(data[0].tx_hash, utxos[0].tx_hash)
-      //   assert.equal(data[0].isValid, false)
-      //
-      //   // Normal TX (non-SLP)
-      //   assert.equal(data[1].tx_hash, utxos[1].tx_hash)
-      //   assert.equal(data[1].isValid, false)
-      //
-      //   // Valid PSF SLP tx
-      //   assert.equal(data[2].tx_hash, utxos[2].tx_hash)
-      //   assert.equal(data[2].isValid, true)
-      //
-      //   // Valid SLP token not in whitelist
-      //   assert.equal(data[3].tx_hash, utxos[3].tx_hash)
-      //   assert.equal(data[3].isValid, true)
-      //
-      //   // Token send on BCHN network
-      //   assert.equal(data[4].tx_hash, utxos[4].tx_hash)
-      //   assert.equal(data[4].isValid, null)
-      //
-      //   // Token send on ABC network
-      //   assert.equal(data[5].tx_hash, utxos[5].tx_hash)
-      //   assert.equal(data[5].isValid, true)
-      //
-      //   // Known invalid SLP token send of PSF tokens
-      //   assert.equal(data[6].tx_hash, utxos[6].tx_hash)
-      //   assert.equal(data[6].isValid, false)
-      // })
+      it("should handle null SLPDB validations", async () => {
+        const utxos = [
+          {
+            height: 665577,
+            tx_hash:
+              "4b89405c54d1c0bde8aa476a47561a42a6e7a5e927daa2ec69d428810eae3419",
+            tx_pos: 1,
+            value: 546
+          },
+          {
+            height: 665577,
+            tx_hash:
+              "3a4b628cbcc183ab376d44ce5252325f042268307ffa4a53443e92b6d24fb488",
+            tx_pos: 1,
+            value: 546
+          }
+        ]
+
+        const data = await bchjs.SLP.Utils.tokenUtxoDetails(utxos)
+        console.log(`data: ${JSON.stringify(data, null, 2)}`)
+      })
     })
 
     describe("#balancesForAddress", () => {
@@ -695,6 +625,82 @@ describe(`#SLP`, () => {
           console.log("Error: ", err)
         }
       })
+
+      it("should handle null SLPDB validations", async () => {
+        const utxos = [
+          {
+            height: 665577,
+            tx_hash:
+              "4b89405c54d1c0bde8aa476a47561a42a6e7a5e927daa2ec69d428810eae3419",
+            tx_pos: 1,
+            value: 546
+          },
+          {
+            height: 665577,
+            tx_hash:
+              "f7e5199ef6669ad4d078093b3ad56e355b6ab84567e59ad0f08a5ad0244f783a",
+            tx_pos: 1,
+            value: 546
+          }
+        ]
+
+        const data = await bchjs.SLP.Utils.hydrateUtxos([{ utxos: utxos }])
+        console.log(`data: ${JSON.stringify(data, null, 2)}`)
+      })
+    })
+
+    describe("#validateTxid", () => {
+      /*
+      it("should return null on a known invalid TXID", async () => {
+        const txid =
+          "f7e5199ef6669ad4d078093b3ad56e355b6ab84567e59ad0f08a5ad0244f783a"
+
+        const result = await bchjs.SLP.Utils.validateTxid(txid)
+        console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+        assert.isArray(result)
+
+        assert.property(result[0], "txid")
+        assert.equal(result[0].txid, txid)
+
+        assert.property(result[0], "valid")
+        assert.equal(result[0].valid, null)
+      })
+
+      it("should return true a known valid TXID", async () => {
+        const txid =
+          "3a4b628cbcc183ab376d44ce5252325f042268307ffa4a53443e92b6d24fb488"
+
+        const result = await bchjs.SLP.Utils.validateTxid(txid)
+        console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+        assert.isArray(result)
+
+        assert.property(result[0], "txid")
+        assert.equal(result[0].txid, txid)
+
+        assert.property(result[0], "valid")
+        assert.equal(result[0].valid, true)
+      })
+*/
+      // This test is not necessary.
+      it("should handle a null response from SLPDB", async () => {
+        const txid =
+          "4b89405c54d1c0bde8aa476a47561a42a6e7a5e927daa2ec69d428810eae3419"
+
+        const result = await bchjs.SLP.Utils.validateTxid(txid)
+        console.log(`result: ${JSON.stringify(result, null, 2)}`)
+      })
+
+      it("should handle a null response from SLPDB", async () => {
+        const txid = [
+          "4b89405c54d1c0bde8aa476a47561a42a6e7a5e927daa2ec69d428810eae3419",
+          "3a4b628cbcc183ab376d44ce5252325f042268307ffa4a53443e92b6d24fb488"
+        ]
+
+        const result = await bchjs.SLP.Utils.validateTxid(txid)
+        console.log(`result: ${JSON.stringify(result, null, 2)}`)
+      })
     })
 
     describe("#validateTxid2", () => {

test/unit/slp-utils.js

@@ -1771,6 +1771,64 @@ describe("#SLP Utils", () => {
       // The UTXO should have been validated by the third validation source.
       assert.equal(data[0].isValid, true)
     })
+
+    it("should handle SLPDB returning null corner case", async () => {
+      // Mock the call to REST API
+      // Stub the calls to decodeOpReturn.
+      sandbox
+        .stub(uut.Utils, "decodeOpReturn")
+        .onCall(0)
+        .resolves({
+          tokenType: 1,
+          txType: "SEND",
+          tokenId:
+            "497291b8a1dfe69c8daea50677a3d31a5ef0e9484d8bebb610dac64bbc202fb7",
+          amounts: ["200000000", "99887500000000"]
+        })
+        .onCall(1)
+        .resolves({
+          tokenType: 1,
+          txType: "GENESIS",
+          ticker: "TOK-CH",
+          name: "TokyoCash",
+          tokenId:
+            "497291b8a1dfe69c8daea50677a3d31a5ef0e9484d8bebb610dac64bbc202fb7",
+          documentUri: "",
+          documentHash: "",
+          decimals: 8,
+          mintBatonVout: 0,
+          qty: "2100000000000000"
+        })
+
+      // Force default SLPDB to return 'null' corner case.
+      sandbox.stub(uut.Utils, "validateTxid").resolves([null])
+
+      // Mock the response from slp-api
+      sandbox.stub(uut.Utils, "validateTxid2").resolves({
+        txid:
+          "fde117b1f176b231e2fa9a6cb022e0f7c31c288221df6bcb05f8b7d040ca87cb",
+        isValid: true,
+        msg: ""
+      })
+
+      const utxos = [
+        {
+          txid:
+            "fde117b1f176b231e2fa9a6cb022e0f7c31c288221df6bcb05f8b7d040ca87cb",
+          vout: 1,
+          amount: 0.00000546,
+          satoshis: 546,
+          height: 596089,
+          confirmations: 748
+        }
+      ]
+
+      const data = await uut.Utils.tokenUtxoDetails(utxos)
+      // console.log(`data: ${JSON.stringify(data, null, 2)}`)
+
+      // The UTXO should have been validated by the third validation source.
+      assert.equal(data[0].isValid, true)
+    })
   })
 
   describe("#txDetails", () => {