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

fix(dependencies): Removing several unused dependencies

.gitignore

@@ -3,6 +3,7 @@ node_modules/*
 wallet-info.txt
 wallet.json
 integration-test-sweet.sh
+integration-test-ss.sh
 
 docs/
 coverage/

package.json

@@ -13,11 +13,11 @@
     "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/chains/testnet/",
-    "test:integration:local": "RESTURL=http://localhost:3000/v4/ mocha --timeout 30000 test/integration",
-    "test:integration:local:bchn": "RESTURL=http://localhost:3000/v4/ mocha --timeout 30000 test/integration/ && mocha --timeout 30000 test/integration/chains/bchn/",
-    "test:integration:local:testnet": "RESTURL=http://localhost:4000/v4/ mocha --timeout 30000 test/integration/testnet",
-    "test:temp": "export RESTURL=https://bchn.fullstack.cash/v4/ && mocha --timeout 30000 -g '#rawtransaction' test/integration/",
-    "test:temp2": "mocha --timeout=30000 -g '#getTxData' test/unit/",
+    "test:integration:local:abc": "export RESTURL=http://localhost:3000/v4/ && mocha --timeout 30000 test/integration && mocha --timeout 30000 test/integration/chains/abc/",
+    "test:integration:local:bchn": "export RESTURL=http://localhost:3000/v4/ && mocha --timeout 30000 test/integration/ && mocha --timeout 30000 test/integration/chains/bchn/",
+    "test:integration:local:testnet": "RESTURL=http://localhost:4000/v4/ mocha --timeout 30000 test/integration/chains/testnet",
+    "test:temp": "export RESTURL=https://bchn.fullstack.cash/v4/ && mocha --timeout 30000 -g '#Encryption' test/integration/",
+    "test:temp2": "mocha --timeout=30000 -g '#Util' 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",
@@ -30,52 +30,36 @@
     "url": "git+https://github.com/Permissionless-Software-Foundation/bch-js.git"
   },
   "dependencies": {
+    "@psf/bip21": "^2.0.1",
+    "@psf/bip32-utils": "^0.13.1",
+    "@psf/bitcoincash-ops": "^2.0.0",
+    "@psf/bitcoincashjs-lib": "^4.0.2",
+    "@psf/coininfo": "^4.0.0",
     "@uppy/core": "^1.10.4",
     "@uppy/tus": "^1.5.12",
-    "assert": "^2.0.0",
     "axios": "^0.21.1",
     "bc-bip68": "^1.0.5",
     "bchaddrjs-slp": "^0.2.5",
     "bigi": "^1.4.2",
     "bignumber.js": "^9.0.0",
     "bip-schnorr": "^0.3.0",
-    "@psf/bip21": "^2.0.1",
-    "@psf/bip32-utils": "^0.13.1",
     "bip38": "^2.0.2",
     "bip39": "^3.0.2",
     "bip66": "^1.1.5",
-    "@psf/bitcoincash-ops": "^2.0.0",
-    "@psf/bitcoincashjs-lib": "^4.0.2",
     "bitcoinjs-message": "^2.0.0",
     "bs58": "^4.0.1",
-    "buffer": "^5.1.0",
     "cashaddrjs": "^0.3.3",
-    "chalk": "^2.3.0",
-    "clear": "0.1.0",
-    "@psf/coininfo": "^4.0.0",
-    "commander": "^3.0.0",
-    "cp-file": "^7.0.0",
-    "ecurve": "^1.0.6",
-    "figlet": "^1.2.0",
-    "git-clone": "^0.1.0",
     "ini": "^1.3.8",
-    "mkdirp": "^0.5.1",
-    "node-cmd": "^3.0.0",
-    "node-emoji": "^1.8.1",
-    "qrcode": "^1.4.1",
     "randombytes": "^2.0.6",
-    "repl.history": "^0.1.4",
     "safe-buffer": "^5.1.2",
     "satoshi-bitcoin": "^1.0.4",
     "slp-mdm": "0.0.6",
     "slp-parser": "0.0.4",
-    "socket.io": "^2.1.1",
-    "socket.io-client": "^2.1.1",
-    "touch": "^3.1.0",
     "wif": "^2.0.6"
   },
   "devDependencies": {
     "apidoc": "^0.17.7",
+    "assert": "^2.0.0",
     "chai": "^4.1.2",
     "coveralls": "^3.0.2",
     "eslint": "5.16.0",
@@ -90,7 +74,7 @@
     "node-mocks-http": "^1.7.0",
     "nyc": "^14.1.0",
     "prettier": "^1.18.2",
-    "semantic-release": "^17.3.1",
+    "semantic-release": "^17.3.9",
     "sinon": "^7.3.2",
     "standard": "^16.0.3"
   },

src/bch-js.js

@@ -26,11 +26,11 @@ const TransactionBuilder = require('./transaction-builder')
 const ECPair = require('./ecpair')
 const Script = require('./script')
 const Price = require('./price')
-const Socket = require('./socket')
 const Schnorr = require('./schnorr')
 const SLP = require('./slp/slp')
 const IPFS = require('./ipfs')
 const Encryption = require('./encryption')
+const Utxo = require('./utxo')
 
 // Indexers
 const Ninsight = require('./ninsight')
@@ -106,13 +106,13 @@ class BCHJS {
     this.TransactionBuilder = TransactionBuilder
     this.TransactionBuilder.setAddress(this.Address)
     this.Util = new Util(libConfig)
-    this.Socket = Socket
     this.Schnorr = new Schnorr(libConfig)
 
     this.SLP = new SLP(libConfig)
     this.SLP.HDNode = this.HDNode
 
     this.IPFS = new IPFS()
+    this.Utxo = new Utxo(libConfig)
   }
 }
 

src/ipfs.js

@@ -14,7 +14,7 @@ class IPFS {
   constructor (config) {
     this.IPFS_API = process.env.IPFS_API
       ? process.env.IPFS_API
-      : 'https://ipfs-api.fullstack.cash'
+      : 'https://ipfs-file-upload.fullstackcash.nl'
     // : `http://localhost:5001`
 
     // Default options when calling axios.

src/raw-transactions.js

@@ -1,5 +1,7 @@
 const axios = require('axios')
 
+const SlpUtils = require('./slp/utils')
+
 let _this
 
 class RawTransactions {
@@ -27,6 +29,9 @@ class RawTransactions {
     // Encapsulate dependencies
     this.axios = axios
 
+    // Dependencies
+    this.slpUtils = new SlpUtils(config)
+
     _this = this
   }
 
@@ -385,6 +390,84 @@ class RawTransactions {
     }
   }
 
+  // Wraps getTxData(), but also appends SLP token information to each input
+  // and output of the transaction. This is a very API-heavy call.
+  // Returns false if the txid is not an SLP transaction.
+  //
+  // Warning! This is a prototype function and the output can change at any time
+  // without reflecting a change in the semantic version. DO NOT USE IN PRODUCTION.
+  async getTxDataSlp (txid) {
+    try {
+      if (typeof txid !== 'string') {
+        throw new Error('Input must be a string or array of strings.')
+      }
+
+      const txDetails = await this.getTxData(txid)
+
+      // First get the token information for the output. If that fails, then
+      // this is not an SLP transaction, and this method can return false.
+      let outTokenData
+      try {
+        outTokenData = await this.slpUtils.decodeOpReturn(txid)
+        // console.log(`outTokenData: ${JSON.stringify(outTokenData, null, 2)}`)
+
+        // Add token information to the tx details object.
+        txDetails.tokenTxType = outTokenData.txType
+        txDetails.tokenId = outTokenData.tokenId
+
+        // Add the token quantity to each output.
+        for (let i = 0; i < outTokenData.amounts.length; i++) {
+          txDetails.vout[i + 1].tokenQty = outTokenData.amounts[i]
+        }
+
+        // Loop through each input and retrieve the token data.
+        for (let i = 0; i < txDetails.vin.length; i++) {
+          const thisVin = txDetails.vin[i]
+
+          try {
+            // If decodeOpReturn() throws an error, then this input is not
+            // from an SLP transaction and can be ignored.
+            const inTokenData = await this.slpUtils.decodeOpReturn(thisVin.txid)
+            // console.log(
+            //   `vin[${i}] tokenData: ${JSON.stringify(inTokenData, null, 2)}`
+            // )
+
+            // Get the appropriate vout token amount. This may throw an error,
+            // which means this Vin is not actually a token UTXO, it was just
+            // associated with a previous token TX.
+            const tokenQty = inTokenData.amounts[thisVin.vout - 1]
+            // console.log(`tokenQty: ${JSON.stringify(tokenQty, null, 2)}`)
+
+            if (tokenQty) {
+              thisVin.tokenQty = tokenQty
+              // txDetails.vin[i].tokenQty = tokenQty
+            } else {
+              thisVin.tokenQty = null
+            }
+          } catch (err) {
+            // console.log('catch 2: ', err)
+            // If decodeOpReturn() throws an error, then this input is not
+            // from an SLP transaction and can be ignored.
+            // thisVin.tokenQty = null
+            thisVin.tokenQty = null
+            continue
+          }
+          // console.log(
+          //   `2: txDetails.vin[i]: ${JSON.stringify(txDetails.vin[i], null, 2)}`
+          // )
+        }
+      } catch (err) {
+        // console.log('catch 1: ', err)
+        return false
+      }
+
+      return txDetails
+    } catch (error) {
+      if (error.response && error.response.data) throw error.response.data
+      else throw error
+    }
+  }
+
   /**
    * @api RawTransactions.sendRawTransaction() sendRawTransaction()
    * @apiName sendRawTransaction

src/slp/tokentype1.js

@@ -118,11 +118,11 @@ class TokenType1 {
 
         // Convert the send quantity to the format expected by slp-mdm.
         const baseQty = sendQtyBig.toString()
-        console.log('baseQty: ', baseQty)
+        // console.log('baseQty: ', baseQty)
 
         // Convert the change quantity to the format expected by slp-mdm.
         const baseChange = change.toString()
-        console.log('baseChange: ', baseChange)
+        // console.log('baseChange: ', baseChange)
 
         // Check for potential burns
         const outputQty = new BigNumber(baseChange).plus(

src/slp/utils.js

@@ -602,7 +602,8 @@ class Utils {
    * @api SLP.Utils.validateTxid3() validateTxid3()
    * @apiName validateTxid3
    * @apiGroup SLP Utils
-   * @apiDescription Validate that txid is an SLP transaction using the SLPDB whitelist server.
+   * @apiDescription
+   * Validate that txid is an SLP transaction using the SLPDB whitelist server.
    * Same exact functionality as the validateTxid() function, but this function
    * calls the whitelist SLPDB. It will only validate SLP tokens that are in the
    * whitelist. You can retrieve the whitelist with the SLP.Utils.whitelist()
@@ -652,6 +653,7 @@ class Utils {
     const path = `${this.restURL}slp/validateTxid3`
 
     // console.log(`txid: ${JSON.stringify(txid, null, 2)}`)
+    // console.log(`path: ${JSON.stringify(path, null, 2)}`)
 
     // Handle a single TXID or an array of TXIDs.
     let txids
@@ -1017,6 +1019,9 @@ class Utils {
    * then SLPDB has not yet processed that txid and validity has not been confirmed,
    * or a 429 rate-limit error was enountered during the processing of the request.
    *
+   * This is an API-heavy call. If you get a lot of null values, then slow down
+   * the calls or request info on fewer UTXOs at a time.
+   *
    * @apiExample Example usage:
    *
    * (async () => {
@@ -1058,10 +1063,6 @@ class Utils {
   // CT 5/31/20: Refactored to use slp-parse library.
   async tokenUtxoDetails (utxos) {
     try {
-      // utxo list may have duplicate tx_hash, varying tx_pos
-      // only need to call decodeOpReturn once for those
-      const decodeOpReturnCache = {}
-      const cachedTxValidation = {}
       // Throw error if input is not an array.
       if (!Array.isArray(utxos)) throw new Error('Input must be an array.')
 
@@ -1070,19 +1071,7 @@ class Utils {
       for (let i = 0; i < utxos.length; i++) {
         const utxo = utxos[i]
 
-        // CT 1/9/21: This code can be removed after 2/1/21
-        // if (!utxo.satoshis) {
-        //   // If Electrumx, convert the value to satoshis.
-        //   if (utxo.value) {
-        //     utxo.satoshis = utxo.value
-        //   } else {
-        //     // If there is neither a satoshis or value property, throw an error.
-        //     throw new Error(
-        //       `utxo ${i} does not have a satoshis or value property.`
-        //     )
-        //   }
-        // }
-
+        // Ensure the UTXO has a txid or tx_hash property.
         if (!utxo.txid) {
           // If Electrumx, convert the tx_hash property to txid.
           if (utxo.tx_hash) {
@@ -1107,6 +1096,131 @@ class Utils {
         }
       }
 
+      // Hydrate each UTXO with data from SLP OP_REUTRNs.
+      const outAry = await this._hydrateUtxo(utxos)
+      // console.log(`outAry: ${JSON.stringify(outAry, null, 2)}`)
+
+      // *After* each UTXO has been hydrated with SLP data,
+      // validate the TXID with SLPDB.
+      for (let i = 0; i < outAry.length; i++) {
+        const utxo = outAry[i]
+
+        // *After* the UTXO has been hydrated with SLP data,
+        // validate the TXID with SLPDB.
+        if (utxo.tokenType) {
+          // Only execute this block if the current UTXO has a 'tokenType'
+          // property. i.e. it has been successfully hydrated with SLP
+          // information.
+
+          // Validate using a 'waterfall' of validators.
+          utxo.isValid = await this.waterfallValidateTxid(utxo.txid)
+          // console.log(`isValid: ${JSON.stringify(utxo.isValid, null, 2)}`)
+        }
+      }
+
+      return outAry
+    } catch (error) {
+      if (error.response && error.response.data) throw error.response.data
+      throw error
+    }
+  }
+
+  /**
+   * @api SLP.Utils.tokenUtxoDetailsWL() tokenUtxoDetailsWL()
+   * @apiName tokenUtxoDetailsWL
+   * @apiGroup SLP Utils
+   * @apiDescription
+   *
+   * Same as tokenUtxoDetails(), but it only uses the whitelist SLPDB to
+   * validate UTXOs. This will result in a lot of `isValid: null` values,
+   * but much more performant handling of SLP tokens. Some wallet apps prefer
+   * the scaling performance over the breadth of supported tokens.
+   *
+   */
+  async tokenUtxoDetailsWL (utxos) {
+    try {
+      // Throw error if input is not an array.
+      if (!Array.isArray(utxos)) throw new Error('Input must be an array.')
+
+      // Loop through each element in the array and validate the input before
+      // further processing.
+      for (let i = 0; i < utxos.length; i++) {
+        const utxo = utxos[i]
+
+        // Ensure the UTXO has a txid or tx_hash property.
+        if (!utxo.txid) {
+          // If Electrumx, convert the tx_hash property to txid.
+          if (utxo.tx_hash) {
+            utxo.txid = utxo.tx_hash
+          } else {
+            // If there is neither a txid or tx_hash property, throw an error.
+            throw new Error(
+              `utxo ${i} does not have a txid or tx_hash property.`
+            )
+          }
+        }
+
+        // Ensure the UTXO has a vout or tx_pos property.
+        if (!Number.isInteger(utxo.vout)) {
+          if (Number.isInteger(utxo.tx_pos)) {
+            utxo.vout = utxo.tx_pos
+          } else {
+            throw new Error(
+              `utxo ${i} does not have a vout or tx_pos property.`
+            )
+          }
+        }
+      }
+
+      // Hydrate each UTXO with data from SLP OP_REUTRNs.
+      const outAry = await this._hydrateUtxo(utxos)
+      // console.log(`outAry: ${JSON.stringify(outAry, null, 2)}`)
+
+      // *After* each UTXO has been hydrated with SLP data,
+      // validate the TXID with SLPDB.
+      for (let i = 0; i < outAry.length; i++) {
+        const utxo = outAry[i]
+
+        // *After* the UTXO has been hydrated with SLP data,
+        // validate the TXID with SLPDB.
+        if (utxo.tokenType) {
+          // Only execute this block if the current UTXO has a 'tokenType'
+          // property. i.e. it has been successfully hydrated with SLP
+          // information.
+
+          // Validate against the whitelist SLPDB.
+          const whitelistResult = await this.validateTxid3(utxo.txid)
+          // console.log(
+          //   `whitelist-SLPDB for ${txid}: ${JSON.stringify(
+          //     whitelistResult,
+          //     null,
+          //     2
+          //   )}`
+          // )
+
+          let isValid = null
+
+          // Safely retrieve the returned value.
+          if (whitelistResult[0] !== null) isValid = whitelistResult[0].valid
+
+          utxo.isValid = isValid
+        }
+      }
+
+      return outAry
+    } catch (error) {
+      if (error.response && error.response.data) throw error.response.data
+      throw error
+    }
+  }
+
+  // This is a private function that is called by tokenUtxoDetails().
+  // It loops through an array of UTXOs and tries to hydrate them with SLP
+  // token information from the OP_RETURN data.
+  async _hydrateUtxo (utxos) {
+    try {
+      const decodeOpReturnCache = {}
+
       // Output Array
       const outAry = []
 
@@ -1166,7 +1280,6 @@ class Utils {
             utxo.vout !== 1 // UTXO is not the reciever of the genesis or mint tokens.
           ) {
             // Can safely be marked as false.
-            // outAry[i] = false
             utxo.isValid = false
             outAry[i] = utxo
           } else {
@@ -1191,7 +1304,6 @@ class Utils {
             utxo.decimals = slpData.decimals
             utxo.tokenType = slpData.tokenType
 
-            // something
             outAry[i] = utxo
           }
         }
@@ -1203,8 +1315,8 @@ class Utils {
             utxo.vout !== 1 // UTXO is not the reciever of the genesis or mint tokens.
           ) {
             // Can safely be marked as false.
-            // outAry[i] = false
             utxo.isValid = false
+
             outAry[i] = utxo
           } else {
             // If UTXO passes validation, then return formatted token data.
@@ -1255,8 +1367,8 @@ class Utils {
           // console.log('tokenQty: ', tokenQty)
 
           if (!tokenQty) {
-            // outAry[i] = false
             utxo.isValid = false
+
             outAry[i] = utxo
           } else {
             // If UTXO passes validation, then return formatted token data.
@@ -1293,130 +1405,6 @@ class Utils {
             outAry[i] = utxo
           }
         }
-
-        // *After* the UTXO has been hydrated with SLP data,
-        // validate the TXID with SLPDB.
-        if (outAry[i].tokenType) {
-          // Only execute this block if the current UTXO has a 'tokenType'
-          // 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) {
-            // 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
-          }
-          // 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(
-            //   `checking against whitelist SLPDB. outAry[${i}]: ${JSON.stringify(
-            //     outAry[i],
-            //     null,
-            //     2
-            //   )}`
-            // )
-
-            // Figure out if the token UTXO is in the whitelist.
-            let utxoInWhitelist = false
-            for (let j = 0; j < this.whitelist.length; j++) {
-              if (outAry[i].tokenId === this.whitelist[j].tokenId) {
-                utxoInWhitelist = true
-                break
-              }
-            }
-
-            // If the utxo.tokenId is in the whitelist, check the validity with
-            // the whitelist SLPDB. This should still be functioning properly
-            // if the general SLPDB is not.
-            if (utxoInWhitelist) {
-              isValid = await this.validateTxid3(utxo.txid)
-
-              // console.log(
-              //   `whitelist-SLPDB for ${utxo.txid}: ${JSON.stringify(
-              //     isValid,
-              //     null,
-              //     2
-              //   )}`
-              // )
-
-              if (isValid[0] !== null) isValid = isValid[0].valid
-
-              // Save the result to the local cache.
-              // 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) {
-            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)}`
-            // )
-
-            if (isValid !== null) isValid = isValid.isValid
-
-            // Save the result to the local cache.
-            // 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
-        }
       }
 
       return outAry
@@ -1426,6 +1414,142 @@ class Utils {
     }
   }
 
+  /**
+   * @api SLP.Utils.waterfallValidateTxid() waterfallValidateTxid()
+   * @apiName waterfallValidateTxid
+   * @apiGroup SLP Utils
+   * @apiDescription Use multiple validators to validate an SLP TXID.
+   *
+   * This function aggregates all the available SLP token validation sources.
+   * It starts with the fastest, most-efficient source first, and continues
+   * to other validation sources until the txid is validated (true or false).
+   * If the txid goes through all sources and can't be validated, it will
+   * return null.
+   *
+   * Validation sources from most efficient to least efficient:
+   * - SLPDB with whitelist filter
+   * - SLPDB general purpose
+   * - slp-api
+   *
+   * Currently only supports a single txid at a time.
+   *
+   * @apiExample Example usage:
+   *
+   * // validate single SLP txid
+   * (async () => {
+   *  try {
+   *    let validated = await bchjs.SLP.Utils.waterfallValidateTxid(
+   *      "df808a41672a0a0ae6475b44f272a107bc9961b90f29dc918d71301f24fe92fb"
+   *    );
+   *    console.log(validated);
+   *  } catch (error) {
+   *    console.error(error);
+   *  }
+   * })();
+   *
+   * // returns
+   * true
+   */
+
+  async waterfallValidateTxid (txid) {
+    try {
+      // console.log('txid: ', txid)
+
+      const cachedTxValidation = {}
+
+      // If the value has been cached, use the cached version first.
+      let isValid = cachedTxValidation[txid]
+      if (!isValid && isValid !== false) {
+        isValid = null
+      } else {
+        return isValid
+      }
+
+      // 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.
+
+      // Validate against the whitelist SLPDB first.
+      const whitelistResult = await this.validateTxid3(txid)
+      // console.log(
+      //   `whitelist-SLPDB for ${txid}: ${JSON.stringify(
+      //     whitelistResult,
+      //     null,
+      //     2
+      //   )}`
+      // )
+
+      // Safely retrieve the returned value.
+      if (whitelistResult[0] !== null) isValid = whitelistResult[0].valid
+
+      // Exit if isValid is not null.
+      if (isValid !== null) {
+        // Save to the cache.
+        cachedTxValidation[txid] = isValid
+
+        return isValid
+      }
+
+      // Try the general SLPDB, if the whitelist returned null.
+      const generalResult = await this.validateTxid(txid)
+      // console.log(
+      //   `validateTxid() isValid: ${JSON.stringify(generalResult, null, 2)}`
+      // )
+
+      // Safely retrieve the returned value.
+      if (generalResult[0] !== null) isValid = generalResult[0].valid
+
+      // Exit if isValid is not null.
+      if (isValid !== null) {
+        // Save to the cache.
+        cachedTxValidation[txid] = isValid
+
+        return isValid
+      }
+
+      // If still null, as a last resort, check it against slp-validate
+      let slpValidateResult = null
+      try {
+        slpValidateResult = await this.validateTxid2(txid)
+      } catch (err) {
+        /* exit quietly */
+      }
+      // console.log(
+      //   `slpValidateResult: ${JSON.stringify(slpValidateResult, null, 2)}`
+      // )
+
+      // Exit if isValid is not null.
+      if (slpValidateResult !== null) {
+        isValid = slpValidateResult.isValid
+
+        // Save to the cache.
+        cachedTxValidation[txid] = isValid
+
+        return isValid
+      }
+
+      // If isValid is still null, return that value, signaling that the txid
+      // could not be validated.
+      return isValid
+    } catch (error) {
+      if (error.response && error.response.data) throw error.response.data
+      throw error
+    }
+  }
+
   /**
    * @api SLP.Utils.hydrateUtxos() hydrateUtxos()
    * @apiName hydrateUtxos
@@ -1442,11 +1566,14 @@ class Utils {
    * set to false.
    * If the UTXO is part of an SLP transaction, it will return the UTXO object
    * with additional SLP information attached. An `isValid` property will be included.
-   * If its value is true, the UTXO is a valid SLP UTXO. \
+   * If its value is true, the UTXO is a valid SLP UTXO.
    * If the isValid value is null,
    * then SLPDB has not yet processed that txid and validity has not been confirmed,
    * or a 429 rate-limit error was enountered during the processing of the request.
    *
+   * This is an API-heavy call. If you get a lot of null values, then slow down
+   * the calls or request info on fewer UTXOs at a time.
+   *
    * @apiExample Example usage:
    *
    * (async () => {
@@ -1611,6 +1738,42 @@ class Utils {
     }
   }
 
+  /**
+   * @api SLP.Utils.hydrateUtxosWL() hydrateUtxosWL()
+   * @apiName hydrateUtxosWL
+   * @apiGroup SLP Utils
+   * @apiDescription
+   * This call is exactly the same as `hydrateUtxos()`. This version hydrate a
+   * UTXO with SLP token metadata, but only uses the whitelist SLPDB for
+   * validation.
+   *
+   * Whitelist SLPDBs will return `isValid: null` for any token not in the
+   * 'whitelist' filter. Filtered SLPDBs are much smaller and more reliable
+   * to operate.
+   *
+   */
+  // Same as tokenUtxoDetailsWL(), but reduces API calls by having bch-api server
+  // do the heavy lifting.
+  async hydrateUtxosWL (utxos) {
+    try {
+      // Throw error if input is not an array.
+      if (!Array.isArray(utxos)) throw new Error('Input must be an array.')
+
+      const response = await _this.axios.post(
+        `${this.restURL}slp/hydrateUtxosWL`,
+        {
+          utxos: utxos
+        },
+        _this.axiosOptions
+      )
+
+      return response.data
+    } catch (error) {
+      if (error.response && error.response.data) throw error.response.data
+      else throw error
+    }
+  }
+
   /**
    * @api SLP.Utils.getStatus() getStatus()
    * @apiName getStatus

src/socket.js

@@ -1,28 +0,0 @@
-const io = require('socket.io-client')
-
-class Socket {
-  constructor (config = {}) {
-    if (typeof config === 'string') {
-      // TODO remove this check in v2.0
-      this.socket = io(`${config}`)
-    } else {
-      if (config.restURL) {
-        this.socket = io(`${config.restURL}`)
-      } else {
-        const restURL = 'https://rest.bitcoin.com'
-        this.socket = io(`${restURL}`)
-      }
-
-      if (config.callback) config.callback()
-    }
-  }
-
-  listen (endpoint, cb) {
-    this.socket.emit(endpoint)
-
-    if (endpoint === 'blocks') this.socket.on('blocks', msg => cb(msg))
-    else if (endpoint === 'transactions') { this.socket.on('transactions', msg => cb(msg)) }
-  }
-}
-
-module.exports = Socket

src/util.js

@@ -27,6 +27,153 @@ class Util {
     _this = this
   }
 
+  /**
+   * @api util.floor8() floor8()
+   * @apiName floor8
+   * @apiGroup Util
+   * @apiDescription Round a number down to 8 decimal places.
+   *
+   *
+   * @apiExample Example usage:
+   * (async () => {
+   *   try {
+   *     const num = 1.234567891111
+   *     const result = bchjs.Util.floor8(num)
+   *     console.log(result)
+   *   } catch(error) {
+   *    console.error(error)
+   *   }
+   * })()
+   *
+   * // returns
+   *  1.23456789
+   */
+  // floor8 - round to 8 decimal places
+  // Takes a number and returns it, rounded to the nearest 8 decimal place.
+  floor8 (num) {
+    const thisNum = Number(num)
+
+    if (isNaN(thisNum)) throw new Error('input must be a number')
+
+    let tempNum = thisNum * 100000000
+    tempNum = Math.floor(tempNum)
+    tempNum = tempNum / 100000000
+
+    return tempNum
+  }
+
+  /**
+   * @api util.floor2() floor2()
+   * @apiName floor2
+   * @apiGroup Util
+   * @apiDescription Round a number down to 2 decimal places.
+   *
+   *
+   * @apiExample Example usage:
+   * (async () => {
+   *   try {
+   *     const num = 1.234567891111
+   *     const result = bchjs.Util.floor2(num)
+   *     console.log(result)
+   *   } catch(error) {
+   *    console.error(error)
+   *   }
+   * })()
+   *
+   * // returns
+   *  1.23
+   */
+  // floor2 - round down to 2 decimal places
+  // Takes a number and returns it, rounded to the nearest 2 decimal place.
+  floor2 (num) {
+    const thisNum = Number(num)
+
+    if (isNaN(thisNum)) throw new Error('input must be a number')
+
+    let tempNum = thisNum * 100
+    tempNum = Math.floor(tempNum)
+    tempNum = tempNum / 100
+
+    return tempNum
+  }
+
+  /**
+   * @api util.chunk20() chunk20()
+   * @apiName chunk20
+   * @apiGroup Util
+   * @apiDescription chunk up an array into multiple arrays of 20 elements each.
+   * Input: arrayToSlice - a one-dimensional array of elements.
+   * Returns a two-dimensional array. An array of 20-element arrays.
+   *
+   * @apiExample Example usage:
+   * (async () => {
+   *   try {
+   *      const bigArray = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26]
+   *
+   *      const chunked = bchjs.Util.chunk20(bigArray)
+   *      console.log(chunked)
+   *   } catch(error) {
+   *      console.error(error)
+   *   }
+   * })()
+   *
+   * // returns
+   *  [
+   *    [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19],
+   *    [20,21,22,23,24,25,26]
+   *  ]
+   */
+  // chunk20 - chunk up an array into multiple arrays of 20 elements each.
+  // Input: arrayToSlice - a one-dimensional array of elements.
+  // Returns a two-dimensional array. An array of 20-element arrays.
+  chunk20 (arrayToSlice) {
+    try {
+      // Validate inputs
+      if (!Array.isArray(arrayToSlice)) {
+        throw new Error('input must be an array')
+      }
+
+      let offset = 0
+      const result = []
+
+      // Loop over the array and slice off chunks of 20 elements.
+      while (offset < arrayToSlice.length) {
+        const chunk = arrayToSlice.slice(offset, offset + 20)
+        result.push(chunk)
+        offset = offset + 20
+      }
+
+      return result
+    } catch (err) {
+      console.error('Error in chunk20()')
+      throw err
+    }
+  }
+
+  /**
+   * @api util.sleep() sleep()
+   * @apiName sleep
+   * @apiGroup Util
+   * @apiDescription Promise-based delay.
+   * Expects an integer as input, which represents milliseconds. This function
+   * will return a Promise that resolves that many milliseconds later.
+   *
+   *
+   * @apiExample Example usage:
+   * (async () => {
+   *   try {
+   *     const tenSeconds = 10000
+   *     await bchjs.Util.sleep(tenSeconds)
+   *   } catch(error) {
+   *    console.error(error)
+   *   }
+   * })()
+   *
+   */
+  sleep (ms) {
+    return new Promise(resolve => setTimeout(resolve, ms))
+  }
+
   /**
    * @api util.validateAddress() validateAddress()
    * @apiName Validate Address.

src/utxo.js

@@ -0,0 +1,348 @@
+/*
+  High-level functions for working with UTXOs
+
+  TODO:
+  - Make a getWL() clone of get(), but uses hydrateUtxosWL()
+*/
+
+// Local libraries
+const Electrumx = require('./electrumx')
+const Slp = require('./slp/slp')
+
+class UTXO {
+  constructor (config) {
+    // Encapsulate dependencies for easier mocking.
+    this.electrumx = new Electrumx(config)
+    this.slp = new Slp(config)
+  }
+
+  /**
+   * @api Utxo.get() get()
+   * @apiName get
+   * @apiGroup UTXO
+   * @apiDescription Get UTXOs for an address
+   *
+   * Given an address, this function will return an object with thre following
+   * properties:
+   * - address: "" - the address these UTXOs are associated with
+   * - bchUtxos: [] - UTXOs confirmed to be spendable as normal BCH
+   * - nullUtxo: [] - UTXOs that did not pass SLP validation. Should be ignored and
+   *   not spent, to be safe.
+   * - slpUtxos: {} - UTXOs confirmed to be colored as valid SLP tokens
+   *   - type1: {}
+   *     - tokens: [] - SLP token Type 1 tokens.
+   *     - mintBatons: [] - SLP token Type 1 mint batons.
+   *   - nft: {}
+   *     - tokens: [] - NFT tokens
+   *     - groupTokens: [] - NFT Group tokens, used to create NFT tokens.
+   *     - groupMintBatons: [] - Minting baton to create more NFT Group tokens.
+   *
+   * Note: You can pass in an optional second Boolean argument. The default
+   * `false` will use the normal waterfall validation method. Set to `true`,
+   * SLP UTXOs will be validated with the whitelist filtered SLPDB. This will
+   * result is many more UTXOs in the `nullUtxos` array.
+   *
+   * @apiExample Example usage:
+   * (async () => {
+   *   try {
+   *     let utxos = await bchjs.Utxo.get('simpleledger:qrm0c67wwqh0w7wjxua2gdt2xggnm90xwsr5k22euj');
+   *     console.log(utxos);
+   *   } catch(error) {
+   *    console.error(error)
+   *   }
+   * })()
+   *
+   * // returns
+   * [
+   *  {
+   *   "address": "bitcoincash:qrm0c67wwqh0w7wjxua2gdt2xggnm90xws00a3lezv",
+   *   "bchUtxos": [
+   *    {
+   *      "height": 674513,
+   *      "tx_hash": "705bcc442e5a2770e560b528f52a47b1dcc9ce9ab6a8de9dfdefa55177f00d04",
+   *      "tx_pos": 3,
+   *      "value": 38134,
+   *      "txid": "705bcc442e5a2770e560b528f52a47b1dcc9ce9ab6a8de9dfdefa55177f00d04",
+   *      "vout": 3,
+   *      "isValid": false
+   *    }
+   *   ],
+   *   "nullUtxos": [],
+   *   "slpUtxos": {
+   *    "type1": {
+   *      "mintBatons": [
+   *        {
+   *          "height": 674512,
+   *          "tx_hash": "acbb0d3ceef55aa3e5fafc19335ae4bf2f8edba3c0567547dfd402391db32230",
+   *          "tx_pos": 2,
+   *          "value": 546,
+   *          "txid": "acbb0d3ceef55aa3e5fafc19335ae4bf2f8edba3c0567547dfd402391db32230",
+   *          "vout": 2,
+   *          "utxoType": "minting-baton",
+   *          "tokenId": "acbb0d3ceef55aa3e5fafc19335ae4bf2f8edba3c0567547dfd402391db32230",
+   *          "tokenTicker": "SLPTEST",
+   *          "tokenName": "SLP Test Token",
+   *          "tokenDocumentUrl": "https://FullStack.cash",
+   *          "tokenDocumentHash": "",
+   *          "decimals": 8,
+   *          "tokenType": 1,
+   *          "isValid": true
+   *        }
+   *      ],
+   *      "tokens": [
+   *        {
+   *          "height": 674512,
+   *          "tx_hash": "acbb0d3ceef55aa3e5fafc19335ae4bf2f8edba3c0567547dfd402391db32230",
+   *          "tx_pos": 1,
+   *          "value": 546,
+   *          "txid": "acbb0d3ceef55aa3e5fafc19335ae4bf2f8edba3c0567547dfd402391db32230",
+   *          "vout": 1,
+   *          "utxoType": "token",
+   *          "tokenQty": "100",
+   *          "tokenId": "acbb0d3ceef55aa3e5fafc19335ae4bf2f8edba3c0567547dfd402391db32230",
+   *          "tokenTicker": "SLPTEST",
+   *          "tokenName": "SLP Test Token",
+   *          "tokenDocumentUrl": "https://FullStack.cash",
+   *          "tokenDocumentHash": "",
+   *          "decimals": 8,
+   *          "tokenType": 1,
+   *          "isValid": true
+   *        }
+   *      ]
+   *   },
+   *   "nft": {
+   *      "groupMintBatons": [
+   *        {
+   *          "height": 674513,
+   *          "tx_hash": "705bcc442e5a2770e560b528f52a47b1dcc9ce9ab6a8de9dfdefa55177f00d04",
+   *          "tx_pos": 2,
+   *          "value": 546,
+   *          "txid": "705bcc442e5a2770e560b528f52a47b1dcc9ce9ab6a8de9dfdefa55177f00d04",
+   *          "vout": 2,
+   *          "utxoType": "minting-baton",
+   *          "transactionType": "mint",
+   *          "tokenId": "a9a2458a0f9f0761d5b8725c256f2e7fa35b9de4dec6f47b46e9f20d92d0e395",
+   *          "tokenType": 129,
+   *          "tokenTicker": "NFTGT",
+   *          "tokenName": "NFT Test Group Token",
+   *          "tokenDocumentUrl": "https://FullStack.cash",
+   *          "tokenDocumentHash": "",
+   *          "decimals": 0,
+   *          "mintBatonVout": 2,
+   *          "isValid": true
+   *        }
+   *      ],
+   *      "groupTokens": [
+   *        {
+   *          "height": 674513,
+   *          "tx_hash": "705bcc442e5a2770e560b528f52a47b1dcc9ce9ab6a8de9dfdefa55177f00d04",
+   *          "tx_pos": 1,
+   *          "value": 546,
+   *          "txid": "705bcc442e5a2770e560b528f52a47b1dcc9ce9ab6a8de9dfdefa55177f00d04",
+   *          "vout": 1,
+   *          "utxoType": "token",
+   *          "tokenQty": "10",
+   *          "transactionType": "mint",
+   *          "tokenId": "a9a2458a0f9f0761d5b8725c256f2e7fa35b9de4dec6f47b46e9f20d92d0e395",
+   *          "tokenType": 129,
+   *          "tokenTicker": "NFTGT",
+   *          "tokenName": "NFT Test Group Token",
+   *          "tokenDocumentUrl": "https://FullStack.cash",
+   *          "tokenDocumentHash": "",
+   *          "decimals": 0,
+   *          "mintBatonVout": 2,
+   *          "isValid": true
+   *        }
+   *      ],
+   *      "tokens": [
+   *        {
+   *          "height": 674512,
+   *          "tx_hash": "eeddccc4d716f04157ea132ac93a48040fea34a6b57f3d8f0cccb7d1a731ab2b",
+   *          "tx_pos": 1,
+   *          "value": 546,
+   *          "txid": "eeddccc4d716f04157ea132ac93a48040fea34a6b57f3d8f0cccb7d1a731ab2b",
+   *          "vout": 1,
+   *          "utxoType": "token",
+   *          "tokenQty": "1",
+   *          "tokenId": "eeddccc4d716f04157ea132ac93a48040fea34a6b57f3d8f0cccb7d1a731ab2b",
+   *          "tokenTicker": "NFT004",
+   *          "tokenName": "NFT Child",
+   *          "tokenDocumentUrl": "https://FullStack.cash",
+   *          "tokenDocumentHash": "",
+   *          "decimals": 0,
+   *          "tokenType": 65,
+   *          "isValid": true
+   *        }
+   *      ]
+   *    }
+   *   }
+   *  }
+   * ]
+   *
+   *
+   */
+  async get (address, useWhitelist = false) {
+    try {
+      // Convert address to an array if it is a string.
+      if (typeof address === 'string') address = [address]
+
+      // Throw an error if there are more than 20 addresses passed in at a time.
+      if (address.length > 20) throw new Error('Too many elements, 20 max.')
+
+      // Covert each address to a BCH address.
+      const addr = address.map(elem => this.slp.Address.toCashAddress(elem))
+
+      // Get the UTXOs associated with the address.
+      const utxoData = await this.electrumx.utxo(addr)
+      // console.log(`utxoData: ${JSON.stringify(utxoData, null, 2)}`)
+
+      // Hydate the utxos with token information.
+      let hydratedUtxos
+      if (useWhitelist) {
+        hydratedUtxos = await this.slp.Utils.hydrateUtxosWL(utxoData.utxos)
+      } else {
+        hydratedUtxos = await this.slp.Utils.hydrateUtxos(utxoData.utxos)
+      }
+      // console.log(`hydratedUtxos: ${JSON.stringify(hydratedUtxos, null, 2)}`)
+
+      const retAry = [] // Return array
+
+      // Loop through each address.
+      for (let i = 0; i < hydratedUtxos.slpUtxos.length; i++) {
+        const thisAddr = hydratedUtxos.slpUtxos[i]
+
+        const addrObj = {
+          address: thisAddr.address
+        }
+
+        // Filter out the different types of UTXOs.
+        addrObj.bchUtxos = thisAddr.utxos.filter(elem => elem.isValid === false)
+        addrObj.nullUtxos = thisAddr.utxos.filter(elem => elem.isValid === null)
+
+        // Break down the SLP UTXOs.
+        addrObj.slpUtxos = {
+          type1: {},
+          nft: {}
+        }
+
+        // Token Type 1 Minting Batons.
+        addrObj.slpUtxos.type1.mintBatons = thisAddr.utxos.filter(elem => {
+          const isValid = elem.isValid === true
+          const tokenTypeIs1 = elem.tokenType === 1
+          const isMintingBaton = elem.utxoType === 'minting-baton'
+
+          return isValid && tokenTypeIs1 && isMintingBaton
+        })
+
+        // Token Type 1 tokens.
+        addrObj.slpUtxos.type1.tokens = thisAddr.utxos.filter(elem => {
+          const isValid = elem.isValid === true
+          const tokenTypeIs1 = elem.tokenType === 1
+          const isToken = elem.utxoType === 'token'
+
+          return isValid && tokenTypeIs1 && isToken
+        })
+
+        // NFT Group Minting Batons
+        addrObj.slpUtxos.nft.groupMintBatons = thisAddr.utxos.filter(elem => {
+          const isValid = elem.isValid === true
+          const tokenTypeIs129 = elem.tokenType === 129
+          const isMintingBaton = elem.utxoType === 'minting-baton'
+
+          return isValid && tokenTypeIs129 && isMintingBaton
+        })
+
+        // NFT Group tokens
+        addrObj.slpUtxos.nft.groupTokens = thisAddr.utxos.filter(elem => {
+          const isValid = elem.isValid === true
+          const tokenTypeIs129 = elem.tokenType === 129
+          const isToken = elem.utxoType === 'token'
+
+          return isValid && tokenTypeIs129 && isToken
+        })
+
+        // NFT (Child) tokens
+        addrObj.slpUtxos.nft.tokens = thisAddr.utxos.filter(elem => {
+          const isValid = elem.isValid === true
+          const tokenTypeIs65 = elem.tokenType === 65
+          const isToken = elem.utxoType === 'token'
+
+          return isValid && tokenTypeIs65 && isToken
+        })
+
+        retAry.push(addrObj)
+      }
+
+      return retAry
+    } catch (err) {
+      console.error('Error in bchjs.utxo.get()')
+      throw err
+    }
+  }
+
+  /**
+   * @api Utxo.findBiggestUtxo() findBiggestUtxo()
+   * @apiName findBiggestUtxo
+   * @apiGroup UTXO
+   * @apiDescription Get the biggest UTXO in an array.
+   *
+   * Given an array of BCH UTXOs, this method will return the biggest UTXO.
+   * This is often the simplest way to pick a UTXO for generating a transaction.
+   *
+   * @apiExample Example usage:
+   * (async () => {
+   *   try {
+   *     const utxos = await bchjs.Utxo.get('bitcoincash:qq54fgjn3hz0357n8a6guy4demw9xfkjk5jcj0xr0z');
+   *     const utxo = bchjs.Utxo.findBiggestUtxo(utxos[0].bchUtxos)
+   *     console.log(utxo);
+   *   } catch(error) {
+   *    console.error(error)
+   *   }
+   * })()
+   *
+   * // returns
+   *  {
+   *   "height": 655431,
+   *   "tx_hash": "7a091716f8137e94f87e7760648cd34a17e32754ef95f7c7bda38a635c9b2b1b",
+   *   "tx_pos": 0,
+   *   "value": 800,
+   *   "txid": "7a091716f8137e94f87e7760648cd34a17e32754ef95f7c7bda38a635c9b2b1b",
+   *   "vout": 0,
+   *   "isValid": false,
+   *   "satoshis": 800
+   *  }
+   */
+  // Returns the utxo with the biggest balance from an array of utxos.
+  findBiggestUtxo (utxos) {
+    let largestAmount = 0
+    let largestIndex = 0
+
+    if (!Array.isArray(utxos)) {
+      throw new Error('utxos input to findBiggestUtxo() must be an array')
+    }
+
+    for (let i = 0; i < utxos.length; i++) {
+      const thisUtxo = utxos[i]
+
+      // Give Elecrumx utxos a satoshis property.
+      if (thisUtxo.value) {
+        if (!thisUtxo.satoshis) thisUtxo.satoshis = Number(thisUtxo.value)
+      }
+
+      if (!thisUtxo.satoshis) {
+        throw new Error(
+          'UTXOs require a satoshis or value property for findBiggestUtxo()'
+        )
+      }
+
+      if (thisUtxo.satoshis > largestAmount) {
+        largestAmount = thisUtxo.satoshis
+        largestIndex = i
+      }
+    }
+
+    return utxos[largestIndex]
+  }
+}
+
+module.exports = UTXO

test/integration/chains/abc/rawtransaction.js

@@ -8,7 +8,7 @@
 const chai = require('chai')
 const assert = chai.assert
 const BCHJS = require('../../../../src/bch-js')
-const bchjs = new BCHJS()
+const bchjs = new BCHJS({ restURL: process.env.RESTURL })
 
 // Inspect utility used for debugging.
 const util = require('util')
@@ -44,6 +44,7 @@ describe('#rawtransaction', () => {
 
         assert.hasAllKeys(err, ['error'])
         assert.include(err.error, 'bad-txns-inputs-missingorspent')
+        // assert.include(err.error, 'Missing inputs')
       }
     })
 
@@ -61,6 +62,7 @@ describe('#rawtransaction', () => {
 
         assert.hasAllKeys(err, ['error'])
         assert.include(err.error, 'bad-txns-inputs-missingorspent')
+        // assert.include(err.error, 'Missing inputs')
       }
     })
   })

test/integration/chains/abc/slp.js

@@ -27,7 +27,7 @@ describe('#SLP', () => {
     // 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()
+    bchjs = new BCHJS({ restURL: process.env.RESTURL })
   })
 
   describe('#util', () => {
@@ -113,6 +113,7 @@ describe('#SLP', () => {
 
         // Token send on BCHN network
         assert.equal(data[4].tx_hash, utxos[4].tx_hash)
+        // assert.equal(data[4].isValid, true)
         assert.equal(data[4].isValid, null)
 
         // Token send on ABC network
@@ -180,6 +181,7 @@ describe('#SLP', () => {
         assert.equal(result[0].valid, null)
         assert.equal(result[1].valid, null)
         assert.equal(result[2].valid, true)
+        // assert.equal(result[2].valid, null)
         assert.equal(result[3].valid, true)
         assert.equal(result[4].valid, null)
       })
@@ -209,6 +211,7 @@ describe('#SLP', () => {
         assert.equal(result[0].valid, null)
         assert.equal(result[1].valid, null)
         assert.equal(result[2].valid, true)
+        // assert.equal(result[2].valid, null)
         assert.equal(result[3].valid, true)
         assert.equal(result[4].valid, null)
         assert.equal(result[5].valid, true)

test/integration/chains/abc/utxo-integration.js

@@ -0,0 +1,38 @@
+/*
+  Integration tests for the utxo.js library.
+*/
+
+const assert = require('chai').assert
+
+const BCHJS = require('../../../../src/bch-js')
+const bchjs = new BCHJS()
+
+describe('#UTXO', () => {
+  beforeEach(async () => {
+    // sandbox = sinon.createSandbox()
+
+    if (process.env.IS_USING_FREE_TIER) await sleep(1000)
+  })
+
+  describe('#get', () => {
+    it('should get hydrated and filtered UTXOs for an address', async () => {
+      // const addr = 'bitcoincash:qqh793x9au6ehvh7r2zflzguanlme760wuzehgzjh9'
+      const addr = 'simpleledger:qzv3zz2trz0xgp6a96lu4m6vp2nkwag0kvyucjzqt9'
+
+      const result = await bchjs.Utxo.get(addr)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.isArray(result)
+      assert.property(result[0], 'address')
+      assert.property(result[0], 'bchUtxos')
+      assert.property(result[0], 'nullUtxos')
+      assert.property(result[0], 'slpUtxos')
+      assert.isArray(result[0].bchUtxos)
+      assert.isArray(result[0].nullUtxos)
+    })
+  })
+})
+
+function sleep (ms) {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}

test/integration/chains/bchn/utxo-integration.js

@@ -0,0 +1,125 @@
+/*
+  Integration tests for the utxo.js library.
+*/
+
+const assert = require('chai').assert
+
+const BCHJS = require('../../../../src/bch-js')
+const bchjs = new BCHJS()
+
+describe('#UTXO', () => {
+  beforeEach(async () => {
+    // sandbox = sinon.createSandbox()
+
+    if (process.env.IS_USING_FREE_TIER) await sleep(1000)
+  })
+
+  describe('#get', () => {
+    it('should get hydrated and filtered UTXOs for an address', async () => {
+      // const addr = 'bitcoincash:qqh793x9au6ehvh7r2zflzguanlme760wuzehgzjh9'
+      const addr = 'simpleledger:qzv3zz2trz0xgp6a96lu4m6vp2nkwag0kvyucjzqt9'
+
+      const result = await bchjs.Utxo.get(addr)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.isArray(result)
+      assert.property(result[0], 'address')
+      assert.property(result[0], 'bchUtxos')
+      assert.property(result[0], 'nullUtxos')
+      assert.property(result[0], 'slpUtxos')
+      assert.isArray(result[0].bchUtxos)
+      assert.isArray(result[0].nullUtxos)
+    })
+
+    it('should handle an array of addresses', async () => {
+      const addr = [
+        'simpleledger:qzv3zz2trz0xgp6a96lu4m6vp2nkwag0kvyucjzqt9',
+        'bitcoincash:qqh793x9au6ehvh7r2zflzguanlme760wuzehgzjh9'
+      ]
+
+      const result = await bchjs.Utxo.get(addr)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.isArray(result)
+      assert.property(result[0], 'address')
+      assert.property(result[0], 'bchUtxos')
+      assert.property(result[0], 'nullUtxos')
+      assert.property(result[0], 'slpUtxos')
+      assert.isArray(result[0].bchUtxos)
+      assert.isArray(result[0].nullUtxos)
+    })
+
+    it('should handle NFTs and minting batons', async () => {
+      const addr = 'simpleledger:qrm0c67wwqh0w7wjxua2gdt2xggnm90xwsr5k22euj'
+
+      const result = await bchjs.Utxo.get(addr)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.isArray(result)
+      assert.property(result[0], 'address')
+      assert.property(result[0], 'bchUtxos')
+      assert.property(result[0], 'nullUtxos')
+      assert.property(result[0], 'slpUtxos')
+      assert.isArray(result[0].bchUtxos)
+      assert.isArray(result[0].nullUtxos)
+
+      assert.isArray(result[0].slpUtxos.type1.mintBatons)
+      assert.isArray(result[0].slpUtxos.type1.tokens)
+      assert.isArray(result[0].slpUtxos.nft.groupMintBatons)
+      assert.isArray(result[0].slpUtxos.nft.groupTokens)
+      assert.isArray(result[0].slpUtxos.nft.tokens)
+    })
+
+    it('should use the whitelist when flag is set', async () => {
+      const addr = 'simpleledger:qzv3zz2trz0xgp6a96lu4m6vp2nkwag0kvyucjzqt9'
+      const useWhitelist = true
+
+      const result = await bchjs.Utxo.get(addr, useWhitelist)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.isArray(result)
+      assert.property(result[0], 'address')
+      assert.property(result[0], 'bchUtxos')
+      assert.property(result[0], 'nullUtxos')
+      assert.property(result[0], 'slpUtxos')
+      assert.isArray(result[0].bchUtxos)
+      assert.isArray(result[0].nullUtxos)
+
+      // Most token UTXOs should end up in the nullUtxos array.
+      assert.isAbove(result[0].bchUtxos.length, 0)
+      assert.isAbove(result[0].nullUtxos.length, 1)
+    })
+  })
+
+  describe('#findBiggestUtxo', () => {
+    it('should sort UTXOs from Electrumx', async () => {
+      const addr = 'bitcoincash:qq54fgjn3hz0357n8a6guy4demw9xfkjk5jcj0xr0z'
+
+      const electrumxUtxos = await bchjs.Electrumx.utxo(addr)
+      // console.log(`Electrumx utxos: ${JSON.stringify(electrumxUtxos, null, 2)}`)
+
+      const result = bchjs.Utxo.findBiggestUtxo(electrumxUtxos.utxos)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.property(result, 'satoshis')
+      assert.equal(result.satoshis, 800)
+    })
+
+    it('should sort UTXOs from Utxos.get()', async () => {
+      const addr = 'bitcoincash:qq54fgjn3hz0357n8a6guy4demw9xfkjk5jcj0xr0z'
+
+      const utxos = await bchjs.Utxo.get(addr)
+      // console.log(`utxos: ${JSON.stringify(utxos, null, 2)}`)
+
+      const result = bchjs.Utxo.findBiggestUtxo(utxos[0].bchUtxos)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.property(result, 'satoshis')
+      assert.equal(result.satoshis, 800)
+    })
+  })
+})
+
+function sleep (ms) {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}

test/integration/implementations/sweet/rawtransaction.js

@@ -1,71 +0,0 @@
-/*
-  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

@@ -1,246 +0,0 @@
-/*
-  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/rawtransaction.js

@@ -238,9 +238,9 @@ describe('#rawtransaction', () => {
         const data = []
         for (let i = 0; i < 25; i++) data.push(dataMock)
 
-        const result = await bchjs.RawTransactions.sendRawTransaction(data)
+        await bchjs.RawTransactions.sendRawTransaction(data)
 
-        console.log(`result: ${util.inspect(result)}`)
+        // console.log(`result: ${util.inspect(result)}`)
         assert.equal(true, false, 'Unexpected result!')
       } catch (err) {
         assert.hasAnyKeys(err, ['error'])
@@ -276,6 +276,30 @@ describe('#rawtransaction', () => {
       assert.property(result.vin[0], 'address')
     })
   })
+
+  describe('#getTxDataSlp', () => {
+    it('should return tx data with SLP information', async () => {
+      const txid = 'b438855cfcab64516b44097d7212df9cdb99226c8d7c7ab504d35fcfd834cb5b'
+
+      const result = await bchjs.RawTransactions.getTxDataSlp(txid)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.property(result.vin[0], 'address')
+      assert.property(result.vin[0], 'tokenQty')
+
+      assert.equal(result.vin[0].tokenQty, null)
+      assert.equal(result.vin[1].tokenQty, '100000000000')
+    })
+
+    it('should handle non-slp tx', async () => {
+      const txid = '04a6aca328af2445327015895b8da9766093b1989b52e477559759eb8072fc0a'
+
+      const result = await bchjs.RawTransactions.getTxDataSlp(txid)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.equal(result, false)
+    })
+  })
 })
 
 function sleep (ms) {

test/integration/slp.js

@@ -32,7 +32,8 @@ describe('#SLP', () => {
   describe('#util', () => {
     describe('#list', () => {
       it('should get information on the Spice token', async () => {
-        const tokenId = '4de69e374a8ed21cbddd47f2338cc0f479dc58daa2bbe11cd604ca488eca0ddf'
+        const tokenId =
+          '4de69e374a8ed21cbddd47f2338cc0f479dc58daa2bbe11cd604ca488eca0ddf'
 
         const result = await bchjs.SLP.Utils.list(tokenId)
         // console.log(`result: ${JSON.stringify(result, null, 2)}`)
@@ -490,6 +491,116 @@ describe('#SLP', () => {
       })
     })
 
+    describe('#tokenUtxoDetailsWL', () => {
+      it('should return details for a simple SEND SLP token utxo', async () => {
+        const utxos = [
+          {
+            height: 660554,
+            tx_hash:
+              '89b3f0c84efe8b01b24e2d7ac08636de5781f31dbb84478e3de868ca0a7ed93a',
+            tx_pos: 1,
+            value: 546
+          }
+        ]
+
+        const data = await bchjs.SLP.Utils.tokenUtxoDetailsWL(utxos)
+        // console.log(`data: ${JSON.stringify(data, null, 2)}`)
+
+        assert.property(data[0], 'txid')
+        assert.property(data[0], 'vout')
+        assert.property(data[0], 'height')
+        assert.property(data[0], 'utxoType')
+        assert.property(data[0], 'tokenId')
+        assert.property(data[0], 'tokenTicker')
+        assert.property(data[0], 'tokenName')
+        assert.property(data[0], 'tokenDocumentUrl')
+        assert.property(data[0], 'tokenDocumentHash')
+        assert.property(data[0], 'decimals')
+        assert.property(data[0], 'tokenQty')
+        assert.property(data[0], 'isValid')
+        assert.equal(data[0].isValid, true)
+      })
+
+      it('should return false for BCH-only UTXOs', async () => {
+        const utxos = [
+          {
+            txid:
+              'a937f792c7c9eb23b4f344ce5c233d1ac0909217d0a504d71e6b1e4efb864a3b',
+            vout: 0,
+            amount: 0.00001,
+            satoshis: 1000,
+            confirmations: 0,
+            ts: 1578424704
+          },
+          {
+            txid:
+              '53fd141c2e999e080a5860887441a2c45e9cbe262027e2bd2ac998fc76e43c44',
+            vout: 0,
+            amount: 0.00001,
+            satoshis: 1000,
+            confirmations: 0,
+            ts: 1578424634
+          }
+        ]
+
+        const data = await bchjs.SLP.Utils.tokenUtxoDetailsWL(utxos)
+        // console.log(`data: ${JSON.stringify(data, null, 2)}`)
+
+        assert.isArray(data)
+        assert.equal(data[0].isValid, false)
+        assert.equal(data[1].isValid, false)
+      })
+
+      it('should handle a dust attack', async () => {
+        // it("#dustattack", async () => {
+        const utxos = [
+          {
+            height: 655965,
+            tx_hash:
+              'a675af87dcd8d39be782737aa52e0076b52eb2f5ce355ffcb5567a64dd96b77e',
+            tx_pos: 151,
+            value: 547,
+            satoshis: 547,
+            txid:
+              'a675af87dcd8d39be782737aa52e0076b52eb2f5ce355ffcb5567a64dd96b77e',
+            vout: 151,
+            address: 'bitcoincash:qq4dw3sm8qvglspy6w2qg0u2ugsy9zcfcqrpeflwww',
+            hdIndex: 11
+          }
+        ]
+
+        const data = await bchjs.SLP.Utils.tokenUtxoDetailsWL(utxos)
+        // console.log(`data: ${JSON.stringify(data, null, 2)}`)
+
+        assert.equal(data[0].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.tokenUtxoDetailsWL(utxos)
+        // console.log(`data: ${JSON.stringify(data, null, 2)}`)
+
+        assert.isArray(data)
+        // assert.equal(data[0].isValid, null)
+      })
+    })
+
     describe('#balancesForAddress', () => {
       it('should fetch all balances for address: simpleledger:qzv3zz2trz0xgp6a96lu4m6vp2nkwag0kvyucjzqt9', async () => {
         const balances = await bchjs.SLP.Utils.balancesForAddress(
@@ -655,6 +766,99 @@ describe('#SLP', () => {
       })
     })
 
+    describe('#hydrateUtxosWL', () => {
+      it('should hydrate UTXOs', async () => {
+        const utxos = [
+          {
+            utxos: [
+              {
+                txid:
+                  '89b3f0c84efe8b01b24e2d7ac08636de5781f31dbb84478e3de868ca0a7ed93a',
+                vout: 1,
+                value: 546
+              }
+            ]
+          }
+        ]
+
+        const result = await bchjs.SLP.Utils.hydrateUtxosWL(utxos)
+        // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+        // Test the general structure of the output.
+        assert.isArray(result.slpUtxos)
+        assert.equal(result.slpUtxos.length, 1)
+        assert.equal(result.slpUtxos[0].utxos.length, 1)
+
+        // Test the non-slp UTXO.
+        assert.property(result.slpUtxos[0].utxos[0], 'txid')
+        assert.property(result.slpUtxos[0].utxos[0], 'vout')
+        assert.property(result.slpUtxos[0].utxos[0], 'value')
+        assert.property(result.slpUtxos[0].utxos[0], 'isValid')
+        assert.equal(result.slpUtxos[0].utxos[0].isValid, true)
+      })
+
+      it('should process data directly from Electrumx', async () => {
+        const addrs = [
+          'bitcoincash:qqnt53cfw990u6y38xgezm0lfa8hknw0wueezcpagp',
+          'bitcoincash:qrh3qgtax6adegzc7zxm6m4sgrv9wq28yqnfn33ce5',
+          'bitcoincash:qqcaee5w4ws77n8s2gzy6fwtma6uxd7ctq8553e495'
+        ]
+
+        const utxos = await bchjs.Electrumx.utxo(addrs)
+        // console.log(`utxos: ${JSON.stringify(utxos, null, 2)}`)
+
+        const result = await bchjs.SLP.Utils.hydrateUtxosWL(utxos.utxos)
+        // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+        // Test the general structure of the output.
+        assert.isArray(result.slpUtxos)
+        assert.equal(result.slpUtxos.length, 3)
+        assert.equal(result.slpUtxos[0].utxos.length, 1)
+        assert.equal(result.slpUtxos[1].utxos.length, 1)
+        assert.equal(result.slpUtxos[2].utxos.length, 2)
+
+        try {
+          // Test the expected values.
+          assert.equal(result.slpUtxos[0].utxos[0].isValid, false)
+          assert.equal(result.slpUtxos[1].utxos[0].isValid, true)
+          assert.equal(result.slpUtxos[1].utxos[0].tokenTicker, 'TROUT')
+          assert.equal(result.slpUtxos[2].utxos[0].isValid, false)
+          // assert.equal(result.slpUtxos[2].utxos[1].isValid, null)
+          assert.equal(result.slpUtxos[2].utxos[1].tokenTicker, 'VALENTINE')
+        } catch (err) {
+          console.error(
+            'The hydrateUtxos call may hitting rate limits, or SLPDB may be having issues if "isValid" results are "null"'
+          )
+          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.hydrateUtxosWL([{ utxos: utxos }])
+        // console.log(`data: ${JSON.stringify(data, null, 2)}`)
+
+        assert.isArray(data.slpUtxos)
+        assert.equal(data.slpUtxos[0].isValid, null)
+      })
+    })
+
     describe('#validateTxid', () => {
       // This test is not necessary.
       it('should handle a null response from SLPDB', async () => {
@@ -735,6 +939,28 @@ describe('#SLP', () => {
         assert.property(result, 'slpProcessedBlockHeight')
       })
     })
+
+    describe('#waterfallValidateTxid', () => {
+      it('should validate known good txid not in whitelist', async () => {
+        const txid =
+          '3a4b628cbcc183ab376d44ce5252325f042268307ffa4a53443e92b6d24fb488'
+
+        const result = await bchjs.SLP.Utils.waterfallValidateTxid(txid)
+        // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+        assert.equal(result, true)
+      })
+
+      it('should invalidate a known invalid TXID', async () => {
+        const txid =
+          'f7e5199ef6669ad4d078093b3ad56e355b6ab84567e59ad0f08a5ad0244f783a'
+
+        const result = await bchjs.SLP.Utils.waterfallValidateTxid(txid)
+        // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+        assert.equal(result, false)
+      })
+    })
   })
 
   describe('#tokentype1', () => {

test/unit/control.js

@@ -5,11 +5,11 @@ const bchjs = new BCHJS()
 const sinon = require('sinon')
 
 describe('#Control', () => {
-  describe('#getNetworkInfo', () => {
-    let sandbox
-    beforeEach(() => (sandbox = sinon.createSandbox()))
-    afterEach(() => sandbox.restore())
+  let sandbox
+  beforeEach(() => (sandbox = sinon.createSandbox()))
+  afterEach(() => sandbox.restore())
 
+  describe('#getNetworkInfo', () => {
     it('should get info', done => {
       const data = {
         version: 170000,
@@ -36,10 +36,6 @@ describe('#Control', () => {
   })
 
   describe('#getMemoryInfo', () => {
-    let sandbox
-    beforeEach(() => (sandbox = sinon.createSandbox()))
-    afterEach(() => sandbox.restore())
-
     it('should get memory info', done => {
       const data = {
         locked: {

test/unit/fixtures/utxo-mocks.js

@@ -0,0 +1,289 @@
+const mockUtxoData = {
+  success: true,
+  utxos: [
+    {
+      utxos: [
+        {
+          height: 569108,
+          tx_hash:
+            '384e1b8197e8de7d38f98317af2cf5f6bcb50007c46943b3498a6fab6e8aeb7c',
+          tx_pos: 1,
+          value: 546
+        },
+        {
+          height: 674331,
+          tx_hash:
+            '5e86cd911110e4f5db0cc3e8f459d5e8850b49adf57059a71daee674b2867b31',
+          tx_pos: 0,
+          value: 1000
+        }
+      ],
+      address: 'bitcoincash:qzv3zz2trz0xgp6a96lu4m6vp2nkwag0kvg8nfhq4m'
+    }
+  ]
+}
+
+const mockHydratedUtxos = {
+  slpUtxos: [
+    {
+      utxos: [
+        {
+          height: 569108,
+          tx_hash:
+            '384e1b8197e8de7d38f98317af2cf5f6bcb50007c46943b3498a6fab6e8aeb7c',
+          tx_pos: 1,
+          value: 546,
+          txid:
+            '384e1b8197e8de7d38f98317af2cf5f6bcb50007c46943b3498a6fab6e8aeb7c',
+          vout: 1,
+          utxoType: 'token',
+          transactionType: 'send',
+          tokenId:
+            'a436c8e1b6bee3d701c6044d190f76f774be83c36de8d34a988af4489e86dd37',
+          tokenTicker: 'sleven',
+          tokenName: 'sleven',
+          tokenDocumentUrl: 'sleven',
+          tokenDocumentHash: '',
+          decimals: 7,
+          tokenType: 1,
+          tokenQty: '1',
+          isValid: true
+        },
+        {
+          height: 674331,
+          tx_hash:
+            '5e86cd911110e4f5db0cc3e8f459d5e8850b49adf57059a71daee674b2867b31',
+          tx_pos: 0,
+          value: 1000,
+          txid:
+            '5e86cd911110e4f5db0cc3e8f459d5e8850b49adf57059a71daee674b2867b31',
+          vout: 0,
+          isValid: false
+        }
+      ],
+      address: 'bitcoincash:qzv3zz2trz0xgp6a96lu4m6vp2nkwag0kvg8nfhq4m'
+    }
+  ]
+}
+
+const mockTwoHydratedAddrs = {
+  slpUtxos: [
+    {
+      utxos: [
+        {
+          height: 569108,
+          tx_hash:
+            '384e1b8197e8de7d38f98317af2cf5f6bcb50007c46943b3498a6fab6e8aeb7c',
+          tx_pos: 1,
+          value: 546,
+          txid:
+            '384e1b8197e8de7d38f98317af2cf5f6bcb50007c46943b3498a6fab6e8aeb7c',
+          vout: 1,
+          utxoType: 'token',
+          transactionType: 'send',
+          tokenId:
+            'a436c8e1b6bee3d701c6044d190f76f774be83c36de8d34a988af4489e86dd37',
+          tokenTicker: 'sleven',
+          tokenName: 'sleven',
+          tokenDocumentUrl: 'sleven',
+          tokenDocumentHash: '',
+          decimals: 7,
+          tokenType: 1,
+          tokenQty: '1',
+          isValid: true
+        },
+        {
+          height: 674331,
+          tx_hash:
+            '5e86cd911110e4f5db0cc3e8f459d5e8850b49adf57059a71daee674b2867b31',
+          tx_pos: 0,
+          value: 1000,
+          txid:
+            '5e86cd911110e4f5db0cc3e8f459d5e8850b49adf57059a71daee674b2867b31',
+          vout: 0,
+          isValid: false
+        }
+      ],
+      address: 'bitcoincash:qzv3zz2trz0xgp6a96lu4m6vp2nkwag0kvg8nfhq4m'
+    },
+    {
+      utxos: [
+        {
+          height: 602405,
+          tx_hash:
+            '2b37bdb3b63dd0bca720437754a36671431a950e684b64c44ea910ea9d5297c7',
+          tx_pos: 0,
+          value: 1000,
+          txid:
+            '2b37bdb3b63dd0bca720437754a36671431a950e684b64c44ea910ea9d5297c7',
+          vout: 0,
+          isValid: false
+        }
+      ],
+      address: 'bitcoincash:qqh793x9au6ehvh7r2zflzguanlme760wuzehgzjh9'
+    }
+  ]
+}
+
+const mockEveryUtxoType = {
+  slpUtxos: [
+    {
+      utxos: [
+        {
+          height: 674512,
+          tx_hash:
+            'acbb0d3ceef55aa3e5fafc19335ae4bf2f8edba3c0567547dfd402391db32230',
+          tx_pos: 1,
+          value: 546,
+          txid:
+            'acbb0d3ceef55aa3e5fafc19335ae4bf2f8edba3c0567547dfd402391db32230',
+          vout: 1,
+          utxoType: 'token',
+          tokenQty: '100',
+          tokenId:
+            'acbb0d3ceef55aa3e5fafc19335ae4bf2f8edba3c0567547dfd402391db32230',
+          tokenTicker: 'SLPTEST',
+          tokenName: 'SLP Test Token',
+          tokenDocumentUrl: 'https://FullStack.cash',
+          tokenDocumentHash: '',
+          decimals: 8,
+          tokenType: 1,
+          isValid: true
+        },
+        {
+          height: 674512,
+          tx_hash:
+            'acbb0d3ceef55aa3e5fafc19335ae4bf2f8edba3c0567547dfd402391db32230',
+          tx_pos: 2,
+          value: 546,
+          txid:
+            'acbb0d3ceef55aa3e5fafc19335ae4bf2f8edba3c0567547dfd402391db32230',
+          vout: 2,
+          utxoType: 'minting-baton',
+          tokenId:
+            'acbb0d3ceef55aa3e5fafc19335ae4bf2f8edba3c0567547dfd402391db32230',
+          tokenTicker: 'SLPTEST',
+          tokenName: 'SLP Test Token',
+          tokenDocumentUrl: 'https://FullStack.cash',
+          tokenDocumentHash: '',
+          decimals: 8,
+          tokenType: 1,
+          isValid: true
+        },
+        {
+          height: 674512,
+          tx_hash:
+            'eeddccc4d716f04157ea132ac93a48040fea34a6b57f3d8f0cccb7d1a731ab2b',
+          tx_pos: 1,
+          value: 546,
+          txid:
+            'eeddccc4d716f04157ea132ac93a48040fea34a6b57f3d8f0cccb7d1a731ab2b',
+          vout: 1,
+          utxoType: 'token',
+          tokenQty: '1',
+          tokenId:
+            'eeddccc4d716f04157ea132ac93a48040fea34a6b57f3d8f0cccb7d1a731ab2b',
+          tokenTicker: 'NFT004',
+          tokenName: 'NFT Child',
+          tokenDocumentUrl: 'https://FullStack.cash',
+          tokenDocumentHash: '',
+          decimals: 0,
+          tokenType: 65,
+          isValid: true
+        },
+        {
+          height: 674513,
+          tx_hash:
+            '705bcc442e5a2770e560b528f52a47b1dcc9ce9ab6a8de9dfdefa55177f00d04',
+          tx_pos: 1,
+          value: 546,
+          txid:
+            '705bcc442e5a2770e560b528f52a47b1dcc9ce9ab6a8de9dfdefa55177f00d04',
+          vout: 1,
+          utxoType: 'token',
+          tokenQty: '10',
+          transactionType: 'mint',
+          tokenId:
+            'a9a2458a0f9f0761d5b8725c256f2e7fa35b9de4dec6f47b46e9f20d92d0e395',
+          tokenType: 129,
+          tokenTicker: 'NFTGT',
+          tokenName: 'NFT Test Group Token',
+          tokenDocumentUrl: 'https://FullStack.cash',
+          tokenDocumentHash: '',
+          decimals: 0,
+          mintBatonVout: 2,
+          isValid: true
+        },
+        {
+          height: 674513,
+          tx_hash:
+            '705bcc442e5a2770e560b528f52a47b1dcc9ce9ab6a8de9dfdefa55177f00d04',
+          tx_pos: 2,
+          value: 546,
+          txid:
+            '705bcc442e5a2770e560b528f52a47b1dcc9ce9ab6a8de9dfdefa55177f00d04',
+          vout: 2,
+          utxoType: 'minting-baton',
+          transactionType: 'mint',
+          tokenId:
+            'a9a2458a0f9f0761d5b8725c256f2e7fa35b9de4dec6f47b46e9f20d92d0e395',
+          tokenType: 129,
+          tokenTicker: 'NFTGT',
+          tokenName: 'NFT Test Group Token',
+          tokenDocumentUrl: 'https://FullStack.cash',
+          tokenDocumentHash: '',
+          decimals: 0,
+          mintBatonVout: 2,
+          isValid: true
+        },
+        {
+          height: 674513,
+          tx_hash:
+            '705bcc442e5a2770e560b528f52a47b1dcc9ce9ab6a8de9dfdefa55177f00d04',
+          tx_pos: 3,
+          value: 38134,
+          txid:
+            '705bcc442e5a2770e560b528f52a47b1dcc9ce9ab6a8de9dfdefa55177f00d04',
+          vout: 3,
+          isValid: false
+        }
+      ],
+      address: 'bitcoincash:qrm0c67wwqh0w7wjxua2gdt2xggnm90xws00a3lezv'
+    }
+  ]
+}
+
+const electrumxUtxos = {
+  success: true,
+  utxos: [
+    {
+      height: 0,
+      tx_hash:
+        '192f5037bb3822afd92d6b6ab51842a5dcfbe6bff783290057342da1f27ed414',
+      tx_pos: 0,
+      value: 600
+    },
+    {
+      height: 0,
+      tx_hash:
+        'f913646f7c180f8de020cb1387951272e8a3f764a0f88e68f7fc1145a0bf02e9',
+      tx_pos: 0,
+      value: 700
+    },
+    {
+      height: 0,
+      tx_hash:
+        '7a091716f8137e94f87e7760648cd34a17e32754ef95f7c7bda38a635c9b2b1b',
+      tx_pos: 0,
+      value: 800
+    }
+  ]
+}
+
+module.exports = {
+  mockUtxoData,
+  mockHydratedUtxos,
+  mockTwoHydratedAddrs,
+  mockEveryUtxoType,
+  electrumxUtxos
+}

test/unit/slp-utils.js

@@ -497,41 +497,6 @@ describe('#SLP Utils', () => {
       }
     })
 
-    // CT 1/9/21: This test can be removed after 2/1/21
-    // it('should throw error if utxo does not have satoshis or value property.', async () => {
-    //   try {
-    //     const utxos = [
-    //       {
-    //         txid:
-    //           'bd158c564dd4ef54305b14f44f8e94c44b649f246dab14bcb42fb0d0078b8a90',
-    //         vout: 3,
-    //         amount: 0.00002015,
-    //         satoshis: 2015,
-    //         height: 594892,
-    //         confirmations: 5
-    //       },
-    //       {
-    //         txid:
-    //           'bd158c564dd4ef54305b14f44f8e94c44b649f246dab14bcb42fb0d0078b8a90',
-    //         vout: 2,
-    //         amount: 0.00000546,
-    //         height: 594892,
-    //         confirmations: 5
-    //       }
-    //     ]
-    //
-    //     await uut.Utils.tokenUtxoDetails(utxos)
-    //
-    //     assert.equal(true, false, 'Unexpected result.')
-    //   } catch (err) {
-    //     assert.include(
-    //       err.message,
-    //       'utxo 1 does not have a satoshis or value property',
-    //       'Expected error message.'
-    //     )
-    //   }
-    // })
-
     it('should throw error if utxo does not have txid or tx_hash property.', async () => {
       try {
         const utxos = [
@@ -569,14 +534,7 @@ describe('#SLP Utils', () => {
     // // change UTXO will contain the same SLP txid, but it is not an SLP UTXO.
     it('should return details on minting baton from genesis transaction', async () => {
       // Mock the call to REST API
-      // Stub the call to validateTxid
-      sandbox.stub(uut.Utils, 'validateTxid').resolves([
-        {
-          txid:
-            'bd158c564dd4ef54305b14f44f8e94c44b649f246dab14bcb42fb0d0078b8a90',
-          valid: true
-        }
-      ])
+      sandbox.stub(uut.Utils, 'waterfallValidateTxid').resolves(true)
 
       // Stub the calls to decodeOpReturn.
       sandbox.stub(uut.Utils, 'decodeOpReturn').resolves({
@@ -675,13 +633,7 @@ describe('#SLP Utils', () => {
         })
 
       // Stub the call to validateTxid
-      sandbox.stub(uut.Utils, 'validateTxid').resolves([
-        {
-          txid:
-            'cf4b922d1e1aa56b52d752d4206e1448ea76c3ebe69b3b97d8f8f65413bd5c76',
-          valid: true
-        }
-      ])
+      sandbox.stub(uut.Utils, 'waterfallValidateTxid').resolves(true)
 
       const utxos = [
         {
@@ -746,14 +698,7 @@ describe('#SLP Utils', () => {
           qty: '2100000000000000'
         })
 
-      // Stub the call to validateTxid
-      sandbox.stub(uut.Utils, 'validateTxid').resolves([
-        {
-          txid:
-            'fde117b1f176b231e2fa9a6cb022e0f7c31c288221df6bcb05f8b7d040ca87cb',
-          valid: true
-        }
-      ])
+      sandbox.stub(uut.Utils, 'waterfallValidateTxid').resolves(true)
 
       const utxos = [
         {
@@ -790,9 +735,10 @@ describe('#SLP Utils', () => {
 
     it('should handle BCH and SLP utxos in the same TX', async () => {
       // Mock external dependencies.
-      sandbox
-        .stub(uut.Utils, 'validateTxid')
-        .resolves(mockData.mockDualValidation)
+      // sandbox
+      //   .stub(uut.Utils, 'validateTxid')
+      //   .resolves(mockData.mockDualValidation)
+      sandbox.stub(uut.Utils, 'waterfallValidateTxid').resolves(true)
 
       sandbox
         .stub(uut.Utils, 'decodeOpReturn')
@@ -898,14 +844,7 @@ describe('#SLP Utils', () => {
           qty: '2000000000000000000'
         })
 
-      // Stub the call to validateTxid
-      sandbox.stub(uut.Utils, 'validateTxid').resolves([
-        {
-          txid:
-            '67fd3c7c3a6eb0fea9ab311b91039545086220f7eeeefa367fa28e6e43009f19',
-          valid: true
-        }
-      ])
+      sandbox.stub(uut.Utils, 'waterfallValidateTxid').resolves(true)
 
       const utxos = [
         {
@@ -1017,14 +956,7 @@ describe('#SLP Utils', () => {
       // Stub the calls to decodeOpReturn.
       sandbox.stub(uut.Utils, 'decodeOpReturn').resolves(slpData)
 
-      // Stub the call to validateTxid
-      sandbox.stub(uut.Utils, 'validateTxid').resolves([
-        {
-          txid:
-            'd2ec6abff5d1c8ed9ab5db6d140dcaebb813463e42933a4a4db171e7222a0954',
-          valid: true
-        }
-      ])
+      sandbox.stub(uut.Utils, 'waterfallValidateTxid').resolves(true)
 
       const utxos = [
         {
@@ -1095,14 +1027,6 @@ describe('#SLP Utils', () => {
         qty: '10000000000'
       }
 
-      const stubValid = [
-        {
-          txid:
-            '880587f01e3112e779c0fdf1b9b859c242a28e56ead85483eeedcaa52f051a04',
-          valid: true
-        }
-      ]
-
       // Mock external dependencies.
       // Stub the calls to decodeOpReturn.
       sandbox
@@ -1118,11 +1042,12 @@ describe('#SLP Utils', () => {
         .resolves(slpData)
 
       // Stub the call to validateTxid
-      sandbox
-        .stub(uut.Utils, 'validateTxid')
-        .resolves(stubValid)
-        .onCall(1)
-        .resolves(stubValid)
+      // sandbox
+      //   .stub(uut.Utils, 'validateTxid')
+      //   .resolves(stubValid)
+      //   .onCall(1)
+      //   .resolves(stubValid)
+      sandbox.stub(uut.Utils, 'waterfallValidateTxid').resolves(true)
 
       const utxos = [
         {
@@ -1184,14 +1109,6 @@ describe('#SLP Utils', () => {
         qty: '1'
       }
 
-      const stubValid = [
-        {
-          txid:
-            '4ef6eb92950a13a69e97c2c02c7967d806aa874c0e2a6b5546a8880f2cd14bc4',
-          valid: true
-        }
-      ]
-
       // Mock external dependencies.
       // Stub the calls to decodeOpReturn.
       sandbox
@@ -1206,14 +1123,7 @@ describe('#SLP Utils', () => {
         .onCall(4)
         .resolves(slpData)
 
-      // Stub the call to validateTxid
-      sandbox
-        .stub(uut.Utils, 'validateTxid')
-        .resolves(stubValid)
-        .onCall(1)
-        .resolves(stubValid)
-        .onCall(2)
-        .resolves(stubValid)
+      sandbox.stub(uut.Utils, 'waterfallValidateTxid').resolves(true)
 
       const utxos = [
         {
@@ -1286,14 +1196,6 @@ describe('#SLP Utils', () => {
         qty: '1'
       }
 
-      const stubValid = [
-        {
-          txid:
-            '35846676e7514658bbd2fd60b1f0d4d86195908f6b2de5328d54c8e4a2d05919',
-          valid: true
-        }
-      ]
-
       // Mock external dependencies.
       // Stub the calls to decodeOpReturn.
       sandbox
@@ -1308,14 +1210,7 @@ describe('#SLP Utils', () => {
         .onCall(4)
         .resolves(genesisData)
 
-      // Stub the call to validateTxid
-      sandbox
-        .stub(uut.Utils, 'validateTxid')
-        .resolves(stubValid)
-        .onCall(1)
-        .resolves(stubValid)
-        .onCall(2)
-        .resolves(stubValid)
+      sandbox.stub(uut.Utils, 'waterfallValidateTxid').resolves(true)
 
       const utxos = [
         {
@@ -1379,14 +1274,6 @@ describe('#SLP Utils', () => {
         qty: '1'
       }
 
-      const stubValid = [
-        {
-          txid:
-            '9b6db26b64aedcedc0bd9a3037b29b3598573ec5cea99eec03faa838616cd683',
-          valid: true
-        }
-      ]
-
       // Mock external dependencies.
       // Stub the calls to decodeOpReturn.
       sandbox
@@ -1395,8 +1282,7 @@ describe('#SLP Utils', () => {
         .onCall(1)
         .resolves(slpData)
 
-      // Stub the call to validateTxid
-      sandbox.stub(uut.Utils, 'validateTxid').resolves(stubValid)
+      sandbox.stub(uut.Utils, 'waterfallValidateTxid').resolves(true)
 
       const utxos = [
         {
@@ -1453,14 +1339,6 @@ describe('#SLP Utils', () => {
         qty: '1'
       }
 
-      const stubValid = [
-        {
-          txid:
-            '6d68a7ffbb63ef851c43025f801a1d365cddda50b00741bca022c743d74cd61a',
-          valid: true
-        }
-      ]
-
       // Mock external dependencies.
       // Stub the calls to decodeOpReturn.
       sandbox
@@ -1471,8 +1349,7 @@ describe('#SLP Utils', () => {
         .onCall(2)
         .resolves(slpData)
 
-      // Stub the call to validateTxid
-      sandbox.stub(uut.Utils, 'validateTxid').resolves(stubValid)
+      sandbox.stub(uut.Utils, 'waterfallValidateTxid').resolves(true)
 
       const utxos = [
         {
@@ -1530,14 +1407,6 @@ describe('#SLP Utils', () => {
         qty: '1'
       }
 
-      const stubValid = [
-        {
-          txid:
-            '57cc47c265ce878679e95e2cec510d8a1a9840f5c62feb4743cc5947d57d9766',
-          valid: true
-        }
-      ]
-
       // Mock external dependencies.
       // Stub the calls to decodeOpReturn.
       sandbox
@@ -1552,12 +1421,7 @@ describe('#SLP Utils', () => {
         .onCall(4)
         .resolves(slpData)
 
-      // Stub the call to validateTxid
-      sandbox
-        .stub(uut.Utils, 'validateTxid')
-        .resolves(stubValid)
-        .onCall(1)
-        .resolves(stubValid)
+      sandbox.stub(uut.Utils, 'waterfallValidateTxid').resolves(true)
 
       const utxos = [
         {
@@ -1695,8 +1559,10 @@ describe('#SLP Utils', () => {
 
       assert.equal(data[0].isValid, false)
     })
+  })
 
-    it('should use backup validators when regular SLPDB returns null', async () => {
+  describe('#tokenUtxoDetailsWL', () => {
+    it('should return details for a simple SEND SLP token utxo', async () => {
       // Mock the call to REST API
       // Stub the calls to decodeOpReturn.
       sandbox
@@ -1724,36 +1590,15 @@ describe('#SLP Utils', () => {
           qty: '2100000000000000'
         })
 
-      // Force default SLPDB to return 'null', which should trigger usage of the
-      // backup whitelist-SLPDB.
-      sandbox.stub(uut.Utils, 'validateTxid').resolves([
-        {
-          txid:
-            'fde117b1f176b231e2fa9a6cb022e0f7c31c288221df6bcb05f8b7d040ca87cb',
-          valid: null
-        }
-      ])
-
-      // Force the token UTXO to be in the whitelist.
-      uut.Utils.whitelist = mockData.whitelist
-
-      // Mock the response from the whitelist-SLPDB.
+      // Stub the call to validateTxid
       sandbox.stub(uut.Utils, 'validateTxid3').resolves([
         {
           txid:
             'fde117b1f176b231e2fa9a6cb022e0f7c31c288221df6bcb05f8b7d040ca87cb',
-          valid: null
+          valid: true
         }
       ])
 
-      // Mock the response from slp-api
-      sandbox.stub(uut.Utils, 'validateTxid2').resolves({
-        txid:
-          'fde117b1f176b231e2fa9a6cb022e0f7c31c288221df6bcb05f8b7d040ca87cb',
-        isValid: true,
-        msg: ''
-      })
-
       const utxos = [
         {
           txid:
@@ -1766,68 +1611,21 @@ describe('#SLP Utils', () => {
         }
       ]
 
-      const data = await uut.Utils.tokenUtxoDetails(utxos)
+      const data = await uut.Utils.tokenUtxoDetailsWL(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)
-    })
-
-    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.property(data[0], 'txid')
+      assert.property(data[0], 'vout')
+      assert.property(data[0], 'height')
+      assert.property(data[0], 'utxoType')
+      assert.property(data[0], 'tokenId')
+      assert.property(data[0], 'tokenTicker')
+      assert.property(data[0], 'tokenName')
+      assert.property(data[0], 'tokenDocumentUrl')
+      assert.property(data[0], 'tokenDocumentHash')
+      assert.property(data[0], 'decimals')
+      assert.property(data[0], 'tokenQty')
+      assert.property(data[0], 'isValid')
       assert.equal(data[0].isValid, true)
     })
   })
@@ -1855,7 +1653,8 @@ describe('#SLP Utils', () => {
             .throws({ error: 'TXID not found' })
         }
 
-        const txid = 'd284e71227ec89f714b964d8eda595be6392bebd2fac46082bc5a9ce6fb7b33e'
+        const txid =
+          'd284e71227ec89f714b964d8eda595be6392bebd2fac46082bc5a9ce6fb7b33e'
 
         await uut.Utils.txDetails(txid)
         // console.log(`result: ${JSON.stringify(result, null, 2)}`)
@@ -1875,7 +1674,8 @@ describe('#SLP Utils', () => {
           .resolves({ data: mockData.mockTxDetails })
       }
 
-      const txid = '9dbaaafc48c49a21beabada8de632009288a2cd52eecefd0c00edcffca9955d0'
+      const txid =
+        '9dbaaafc48c49a21beabada8de632009288a2cd52eecefd0c00edcffca9955d0'
 
       const result = await uut.Utils.txDetails(txid)
       // console.log(`result: ${JSON.stringify(result, null, 2)}`)
@@ -1916,6 +1716,21 @@ describe('#SLP Utils', () => {
     })
   })
 
+  describe('#hydrateUtxosWL', () => {
+    it('should throw an error if input is not an array', async () => {
+      try {
+        const utxos = 1234
+
+        await uut.Utils.hydrateUtxosWL(utxos)
+
+        assert.equal(true, false, 'Uh oh. Code path should not end here.')
+      } catch (err) {
+        // console.log(`Error: `, err)
+        assert.include(err.message, 'Input must be an array.')
+      }
+    })
+  })
+
   describe('#validateTxid2', () => {
     it('should throw an error if the input is an array', async () => {
       try {
@@ -2055,6 +1870,86 @@ describe('#SLP Utils', () => {
 */
   })
 
+  describe('#waterfallValidateTxid', () => {
+    // This test ensures that the whitelist SLPDB is called before the
+    // general purpose SLPDB.
+    it('should call validateTxid3() first', async () => {
+      const txid = 'fakeTxid'
+
+      const retVal = [{ txid, valid: true }]
+
+      // Use stubs to force the desired code path.
+      sandbox.stub(uut.Utils, 'validateTxid3').resolves(retVal)
+      sandbox
+        .stub(uut.Utils, 'validateTxid')
+        .rejects(new Error('Unexpected code path'))
+      sandbox
+        .stub(uut.Utils, 'validateTxid2')
+        .rejects(new Error('Unexpected code path'))
+
+      const result = await uut.Utils.waterfallValidateTxid(txid)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.equal(result, true)
+    })
+
+    // This test ensures that the general purpose SLPDB is called after the
+    // whitelist SLPDB, but before slp-api.
+    it('should call validateTxid() second', async () => {
+      const txid = 'fakeTxid'
+
+      const retVal1 = [{ txid, valid: null }]
+      const retVal2 = [{ txid, valid: true }]
+
+      // Use stubs to force the desired code path.
+      sandbox.stub(uut.Utils, 'validateTxid3').resolves(retVal1)
+      sandbox.stub(uut.Utils, 'validateTxid').resolves(retVal2)
+      sandbox
+        .stub(uut.Utils, 'validateTxid2')
+        .rejects(new Error('Unexpected code path'))
+
+      const result = await uut.Utils.waterfallValidateTxid(txid)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.equal(result, true)
+    })
+
+    // This test ensures that slp-api is called if both SLPDBs return null.
+    it('should call slp-api last', async () => {
+      const txid = 'fakeTxid'
+
+      const retVal1 = [{ txid, valid: null }]
+
+      // Use stubs to force the desired code path.
+      sandbox.stub(uut.Utils, 'validateTxid3').resolves(retVal1)
+      sandbox.stub(uut.Utils, 'validateTxid').resolves(retVal1)
+      sandbox.stub(uut.Utils, 'validateTxid2').resolves({ isValid: true })
+
+      const result = await uut.Utils.waterfallValidateTxid(txid)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.equal(result, true)
+    })
+
+    it('catches and throws an error', async () => {
+      try {
+        const txid = 'fakeTxid'
+
+        // Force an error
+        sandbox
+          .stub(uut.Utils, 'validateTxid3')
+          .rejects(new Error('fake error'))
+
+        await await uut.Utils.waterfallValidateTxid(txid)
+
+        assert.fail('Unexpected result')
+      } catch (err) {
+        // console.log(`err.message: ${err.message}`)
+        assert.include(err.message, 'fake error')
+      }
+    })
+  })
+
   describe('#getWhitelist', () => {
     it('should return the list', async () => {
       sandbox

test/unit/util.js

@@ -1,4 +1,5 @@
 const assert = require('assert')
+const assert2 = require('chai').assert
 const axios = require('axios')
 const BCHJS = require('../../src/bch-js')
 const bchjs = new BCHJS()
@@ -32,4 +33,143 @@ describe('#Util', () => {
         .then(done, done)
     })
   })
+
+  describe('#floor8', () => {
+    it('should floor a number to 8 decimals', () => {
+      const num = 1.234567891111
+
+      const result = bchjs.Util.floor8(num)
+      // console.log(result)
+
+      assert2.equal(result, 1.23456789)
+    })
+
+    it('should throw an error for non-number input', () => {
+      try {
+        const num = 'string'
+
+        bchjs.Util.floor8(num)
+
+        assert2.equal(true, false, 'Unexpected result')
+      } catch (err) {
+        // console.log(err)
+        assert2.include(err.message, 'input must be a number')
+      }
+    })
+
+    it('should not effect a number with less than 8 decimals', () => {
+      const num = 1.23
+
+      const result = bchjs.Util.floor8(num)
+      // console.log(result)
+
+      assert2.equal(result, 1.23)
+    })
+  })
+
+  describe('#floor2', () => {
+    it('should round a number to 2 decimals', () => {
+      const num = 1.234567891111
+
+      const result = bchjs.Util.floor2(num)
+      // console.log(result)
+
+      assert2.equal(result, 1.23)
+    })
+
+    it('should throw an error for non-number input', () => {
+      try {
+        const num = 'string'
+
+        bchjs.Util.floor2(num)
+
+        assert2.equal(true, false, 'Unexpected result')
+      } catch (err) {
+        // console.log(err)
+        assert2.include(err.message, 'input must be a number')
+      }
+    })
+
+    it('should not effect a number with less than 8 decimals', () => {
+      const num = 1.2
+
+      const result = bchjs.Util.floor2(num)
+      // console.log(result)
+
+      assert2.equal(result, 1.2)
+    })
+  })
+
+  describe('#chunk20', () => {
+    const thirtyFiveElements = [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      16,
+      17,
+      18,
+      19,
+      20,
+      21,
+      22,
+      23,
+      24,
+      25,
+      26,
+      27,
+      28,
+      29,
+      30,
+      31,
+      32,
+      33,
+      34
+    ]
+
+    it('should split 35 elements into 2 arrays', () => {
+      const result = bchjs.Util.chunk20(thirtyFiveElements)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert2.isArray(result)
+      assert2.isArray(result[0])
+      assert2.equal(result.length, 2)
+      assert2.equal(result[0].length, 20)
+    })
+
+    it('should return accurately with an array of less than 20 elements', () => {
+      const elems = [0, 1, 2, 3, 4, 5]
+
+      const result = bchjs.Util.chunk20(elems)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert2.isArray(result)
+      assert2.isArray(result[0])
+      assert2.equal(result.length, 1)
+      assert2.equal(result[0].length, 6)
+    })
+
+    it('should throw an error for non-array input', () => {
+      try {
+        bchjs.Util.chunk20('string')
+
+        assert2.equal(true, false, 'Unexpected result')
+      } catch (err) {
+        // console.log(err)
+        assert2.include(err.message, 'input must be an array')
+      }
+    })
+  })
 })

test/unit/utxo-unit.js

@@ -0,0 +1,191 @@
+/*
+  Unit tests for the utxo.js library.
+*/
+
+const sinon = require('sinon')
+const assert = require('chai').assert
+
+const BCHJS = require('../../src/bch-js')
+const bchjs = new BCHJS()
+
+const mockData = require('./fixtures/utxo-mocks')
+
+describe('#utxo', () => {
+  let sandbox
+  beforeEach(() => (sandbox = sinon.createSandbox()))
+  afterEach(() => sandbox.restore())
+
+  describe('#get', () => {
+    it('should get hydrated and filtered UTXOs for an address', async () => {
+      // Mock dependencies.
+      sandbox.stub(bchjs.Utxo.electrumx, 'utxo').resolves(mockData.mockUtxoData)
+      sandbox
+        .stub(bchjs.Utxo.slp.Utils, 'hydrateUtxos')
+        .resolves(mockData.mockHydratedUtxos)
+
+      const addr = 'simpleledger:qzv3zz2trz0xgp6a96lu4m6vp2nkwag0kvyucjzqt9'
+
+      const result = await bchjs.Utxo.get(addr)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.isArray(result)
+      assert.property(result[0], 'address')
+      assert.property(result[0], 'bchUtxos')
+      assert.property(result[0], 'nullUtxos')
+      assert.property(result[0], 'slpUtxos')
+      assert.isArray(result[0].bchUtxos)
+      assert.isArray(result[0].nullUtxos)
+    })
+
+    it('should catch and throw an error', async () => {
+      try {
+        // Force an error
+        sandbox
+          .stub(bchjs.Utxo.electrumx, 'utxo')
+          .rejects(new Error('test error'))
+
+        const addr = 'simpleledger:qzv3zz2trz0xgp6a96lu4m6vp2nkwag0kvyucjzqt9'
+
+        await bchjs.Utxo.get(addr)
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'test error')
+      }
+    })
+
+    it('should handle an array of addresses', async () => {
+      // Mock dependencies.
+      sandbox.stub(bchjs.Utxo.electrumx, 'utxo').resolves({ utxos: {} })
+      sandbox
+        .stub(bchjs.Utxo.slp.Utils, 'hydrateUtxos')
+        .resolves(mockData.mockTwoHydratedAddrs)
+
+      const addr = [
+        'simpleledger:qzv3zz2trz0xgp6a96lu4m6vp2nkwag0kvyucjzqt9',
+        'bitcoincash:qqh793x9au6ehvh7r2zflzguanlme760wuzehgzjh9'
+      ]
+
+      const result = await bchjs.Utxo.get(addr)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.isArray(result)
+      assert.equal(result.length, 2)
+      assert.property(result[0], 'address')
+      assert.property(result[0], 'bchUtxos')
+      assert.property(result[0], 'nullUtxos')
+      assert.property(result[0], 'slpUtxos')
+      assert.isArray(result[0].bchUtxos)
+      assert.isArray(result[0].nullUtxos)
+    })
+
+    it('should throw an error for array of 21 elements', async () => {
+      try {
+        const addr = 'simpleledger:qzv3zz2trz0xgp6a96lu4m6vp2nkwag0kvyucjzqt9'
+
+        const addrs = []
+        for (let i = 0; i < 21; i++) {
+          addrs.push(addr)
+        }
+
+        await bchjs.Utxo.get(addrs)
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'Too many elements, 20 max.')
+      }
+    })
+
+    it('should handle NFTs and minting batons', async () => {
+      // Mock dependencies.
+      sandbox.stub(bchjs.Utxo.electrumx, 'utxo').resolves({ utxos: {} })
+      sandbox
+        .stub(bchjs.Utxo.slp.Utils, 'hydrateUtxos')
+        .resolves(mockData.mockEveryUtxoType)
+
+      const addr = 'simpleledger:qrm0c67wwqh0w7wjxua2gdt2xggnm90xwsr5k22euj'
+
+      const result = await bchjs.Utxo.get(addr)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.isArray(result)
+      assert.property(result[0], 'address')
+      assert.property(result[0], 'bchUtxos')
+      assert.property(result[0], 'nullUtxos')
+      assert.property(result[0], 'slpUtxos')
+      assert.isArray(result[0].bchUtxos)
+      assert.isArray(result[0].nullUtxos)
+
+      assert.isArray(result[0].slpUtxos.type1.mintBatons)
+      assert.isArray(result[0].slpUtxos.type1.tokens)
+      assert.isArray(result[0].slpUtxos.nft.groupMintBatons)
+      assert.isArray(result[0].slpUtxos.nft.groupTokens)
+      assert.isArray(result[0].slpUtxos.nft.tokens)
+    })
+
+    it('should use the whitelist when flag is set', async () => {
+      // Mock dependencies.
+      sandbox.stub(bchjs.Utxo.electrumx, 'utxo').resolves(mockData.mockUtxoData)
+      sandbox
+        .stub(bchjs.Utxo.slp.Utils, 'hydrateUtxosWL')
+        .resolves(mockData.mockHydratedUtxos)
+
+      const addr = 'simpleledger:qzv3zz2trz0xgp6a96lu4m6vp2nkwag0kvyucjzqt9'
+      const useWhitelist = true
+
+      const result = await bchjs.Utxo.get(addr, useWhitelist)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.isArray(result)
+      assert.property(result[0], 'address')
+      assert.property(result[0], 'bchUtxos')
+      assert.property(result[0], 'nullUtxos')
+      assert.property(result[0], 'slpUtxos')
+      assert.isArray(result[0].bchUtxos)
+      assert.isArray(result[0].nullUtxos)
+    })
+  })
+
+  describe('#findBiggestUtxo', () => {
+    it('should throw error for non-array input', async () => {
+      try {
+        await bchjs.Utxo.findBiggestUtxo({})
+
+        assert.equal(true, false, 'Unexpected result!')
+      } catch (err) {
+        assert.include(
+          err.message,
+          'utxos input to findBiggestUtxo() must be an array'
+        )
+      }
+    })
+
+    it('should throw an error if input does not have a value or satoshis property', async () => {
+      try {
+        const badUtxos = [
+          {
+            height: 0,
+            tx_hash:
+              '192f5037bb3822afd92d6b6ab51842a5dcfbe6bff783290057342da1f27ed414',
+            tx_pos: 0
+          }
+        ]
+
+        await bchjs.Utxo.findBiggestUtxo(badUtxos)
+      } catch (err) {
+        assert.include(
+          err.message,
+          'UTXOs require a satoshis or value property for findBiggestUtxo()'
+        )
+      }
+    })
+
+    it('should sort UTXOs from Electrumx', async () => {
+      const result = bchjs.Utxo.findBiggestUtxo(mockData.electrumxUtxos.utxos)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.property(result, 'satoshis')
+      assert.equal(result.satoshis, 800)
+    })
+  })
+})