@psf/bch-js 4.22.0 → 5.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@psf/bch-js",
-  "version": "4.22.0",
+  "version": "5.2.1",
   "description": "The FullStack.cash JavaScript library for Bitcoin Cash and SLP Tokens",
   "author": "Chris Troutner <chris.troutner@gmail.com>",
   "contributors": [
@@ -14,11 +14,11 @@
     "test:integration:nft": "export RESTURL=https://bchn.fullstack.cash/v5/ && export IS_USING_FREE_TIER=true && mocha --timeout 30000 -g '#nft1' test/integration/chains/bchn/slp.js",
     "test:integration:abc": "export RESTURL=https://abc.fullstack.cash/v5/ && 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/v5/ && 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:bchn:slpdb": "export TESTSLP=1 && export RESTURL=https://bchn.fullstack.cash/v5/ && export IS_USING_FREE_TIER=true && mocha --timeout 30000 test/integration/ && mocha --timeout 30000 test/integration/chains/bchn/",
     "test:integration:local:abc": "export RESTURL=http://localhost:3000/v5/ && mocha --timeout 30000 test/integration && mocha --timeout 30000 test/integration/chains/abc/",
     "test:integration:local:bchn": "export RESTURL=http://localhost:3000/v5/ && mocha --timeout 30000 test/integration/ && mocha --timeout 30000 test/integration/chains/bchn/",
     "test:integration:local:testnet": "RESTURL=http://localhost:4000/v5/ mocha --timeout 30000 test/integration/chains/testnet",
-    "test:integration:decatur:bchn": "export RESTURL=http://192.168.2.129:3000/v5/ && mocha --timeout 30000 test/integration/ && mocha --timeout 30000 test/integration/chains/bchn/",
+    "test:integration:decatur:bchn": "export RESTURL=http://192.168.2.139:3000/v5/ && mocha --timeout 30000 test/integration/ && mocha --timeout 30000 test/integration/chains/bchn/",
     "test:integration:decatur:abc": "export RESTURL=http://192.168.2.141:3000/v5/ && mocha --timeout 30000 test/integration && mocha --timeout 30000 test/integration/chains/abc/",
     "test:integration:temp:bchn": "export RESTURL=http://157.90.174.219:3000/v5/ && mocha --timeout 30000 test/integration/",
     "test:temp": "export RESTURL=http://localhost:3000/v5/ && mocha --timeout 30000 -g '#Encryption' test/integration/",

package/src/bch-js.js

@@ -36,7 +36,6 @@ const DSProof = require('./dsproof')
 const Ecash = require('./ecash')
 
 // Indexers
-const Ninsight = require('./ninsight')
 const Electrumx = require('./electrumx')
 const PsfSlpIndexer = require('./psf-slp-indexer')
 
@@ -83,9 +82,6 @@ class BCHJS {
 
     // console.log(`apiToken: ${this.apiToken}`)
 
-    // Bitcoin.com Ninsight indexer
-    this.Ninsight = new Ninsight(config)
-
     // ElectrumX indexer
     this.Electrumx = new Electrumx(libConfig)
 

package/src/psf-slp-indexer.js

@@ -1,14 +1,22 @@
 /*
   This library interacts with the PSF slp indexer REST API endpoints operated
   by FullStack.cash
+
+  TODO:
+  - detect TXs from tokens in the blacklist.
 */
+
 // Public npm libraries
 const axios = require('axios')
 
+// Local libraries
+const RawTransaction = require('./raw-transactions')
+const SlpUtils = require('./slp/utils')
+
 // let _this
 
 class PsfSlpIndexer {
-  constructor (config) {
+  constructor (config = {}) {
     this.restURL = config.restURL
     this.apiToken = config.apiToken
     this.authToken = config.authToken
@@ -29,6 +37,10 @@ class PsfSlpIndexer {
       }
     }
 
+    // Encapsulate dependencies
+    this.rawTransaction = new RawTransaction(config)
+    this.slpUtils = new SlpUtils(config)
+
     // _this = this
   }
 
@@ -120,6 +132,7 @@ class PsfSlpIndexer {
    */
   async balance (address) {
     try {
+      console.log('balance() address: ', address)
       // Handle single address.
       if (typeof address === 'string') {
         const response = await axios.post(
@@ -283,8 +296,73 @@ class PsfSlpIndexer {
       }
       throw new Error('Input txid must be a string.')
     } catch (error) {
-      if (error.response && error.response.data) throw error.response.data
-      else throw error
+      // console.log('error: ', error)
+
+      // Case: txid is not stored in the psf-slp-indexer tx database.
+      // Response: If it's not in the database, then it can be assumed the TX
+      // is not a token TX?
+      if (
+        error.response &&
+        error.response.data &&
+        error.response.data.error &&
+        error.response.data.error.includes('Key not found in database')
+      ) {
+        // console.log(
+        //   'TX not found in psf-slp-indexer. Retrieving from full node.'
+        // )
+
+        // Check if this txid belongs to a blacklisted token.
+        const isInBlacklist = await this.checkBlacklist(txid)
+
+        // Get the TX Details from the full node.
+        const txDetails = await this.rawTransaction.getTxData(txid)
+        // console.log(`txDetails: ${JSON.stringify(txDetails, null, 2)}`)
+
+        if (isInBlacklist) {
+          txDetails.isValidSlp = null
+        } else {
+          txDetails.isValidSlp = false
+        }
+
+        const outObj = {
+          txData: txDetails
+        }
+
+        return outObj
+      } else throw error
+    }
+  }
+
+  // Check if the txid has an OP_RETURN containing a tokenID that is in the
+  // blacklist. In that case, the isValidSlp property should be marked as
+  // null, and not false.
+  async checkBlacklist (txid) {
+    try {
+      // TODO: Add endpoint to psf-slp-indexer to retrieve current blacklist.
+      // This should be done once at startup, and not each time this function
+      // is called.
+      const blacklist = [
+        'dd21be4532d93661e8ffe16db6535af0fb8ee1344d1fef81a193e2b4cfa9fbc9'
+      ]
+
+      const outTokenData = await this.slpUtils.decodeOpReturn(txid)
+      // console.log('outTokenData: ', outTokenData)
+
+      // Loop through each token in the blacklist.
+      for (let i = 0; i < blacklist.length; i++) {
+        // If a match is found, return true.
+        if (outTokenData.tokenId === blacklist[i]) {
+          return true
+        }
+      }
+
+      // By default, return false.
+      return false
+    } catch (err) {
+      // console.log(err)
+
+      // Exit quietly.
+      return false
     }
   }
 }

package/src/slp/utils.js

@@ -11,7 +11,7 @@ const Util = require('../util')
 let _this
 
 class Utils {
-  constructor (config) {
+  constructor (config = {}) {
     this.restURL = config.restURL
     this.apiToken = config.apiToken
     this.slpParser = slpParser

package/src/transaction.js

@@ -2,18 +2,27 @@
   High-level functions for working with Transactions
 */
 
+// Global npm libraries
 const BigNumber = require('bignumber.js')
 
+// Local libraries
 const RawTransaction = require('./raw-transactions')
 const SlpUtils = require('./slp/utils')
 const Blockchain = require('./blockchain')
+const PsfSlpIndexer = require('./psf-slp-indexer')
 
 class Transaction {
-  constructor (config) {
+  constructor (config = {}) {
     // Encapsulate dependencies
     this.slpUtils = new SlpUtils(config)
     this.rawTransaction = new RawTransaction(config)
     this.blockchain = new Blockchain(config)
+    this.psfSlpIndexer = new PsfSlpIndexer(config)
+  }
+
+  // Proxy the call to the psf-slp-indexer.
+  async get (txid) {
+    return await this.psfSlpIndexer.tx(txid)
   }
 
   /**
@@ -42,7 +51,7 @@ class Transaction {
   // CT 10/31/21: TODO: this function should be refactored to use get2(), but
   // add waterfall validation of the TX and its inputs.
 
-  async get (txid) {
+  async getOld (txid) {
     try {
       if (typeof txid !== 'string') {
         throw new Error(

package/src/utxo.js

@@ -8,19 +8,23 @@
 // Local libraries
 const Electrumx = require('./electrumx')
 const Slp = require('./slp/slp')
+const PsfSlpIndexer = require('./psf-slp-indexer')
+const BigNumber = require('bignumber.js')
 
 class UTXO {
-  constructor (config) {
+  constructor (config = {}) {
     // Encapsulate dependencies for easier mocking.
     this.electrumx = new Electrumx(config)
     this.slp = new Slp(config)
+    this.psfSlpIndexer = new PsfSlpIndexer(config)
+    this.BigNumber = BigNumber
   }
 
   /**
-   * @api Utxo.get() get()
-   * @apiName get
+   * @api Utxo.getOld() getOld()
+   * @apiName getOld
    * @apiGroup UTXO
-   * @apiDescription Get UTXOs for an address
+   * @apiDescription Get UTXOs for an address (from SLPDB)
    *
    * Given an address, this function will return an object with thre following
    * properties:
@@ -45,7 +49,7 @@ class UTXO {
    * @apiExample Example usage:
    * (async () => {
    *   try {
-   *     let utxos = await bchjs.Utxo.get('simpleledger:qrm0c67wwqh0w7wjxua2gdt2xggnm90xwsr5k22euj');
+   *     let utxos = await bchjs.Utxo.getOld('simpleledger:qrm0c67wwqh0w7wjxua2gdt2xggnm90xwsr5k22euj');
    *     console.log(utxos);
    *   } catch(error) {
    *    console.error(error)
@@ -181,7 +185,7 @@ class UTXO {
    *
    *
    */
-  async get (address, useWhitelist = false) {
+  async getOld (address, useWhitelist = false) {
     try {
       if (!address) {
         throw new Error('Address must be an array or a string')
@@ -286,6 +290,207 @@ class UTXO {
     }
   }
 
+  /**
+   * @api Utxo.get() get()
+   * @apiName get
+   * @apiGroup UTXO
+   * @apiDescription Get UTXOs for an address (from psf-slp-indexer)
+   *
+   * 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
+   *    }
+   *   ],
+   */
+  // This version of get() uses the psf-slp-indexer. It will replace the older
+  // get() function that uses SLPDB.
+  // TODO: NFT UTXOs are identified as non-token UTXOs, which will cause a wallet
+  // to burn them. The psf-slp-indexer needs to be updated to mark these UTXOs.
+  async get (address) {
+    try {
+      // Convert address to an array if it is a string.
+      if (typeof address !== 'string') {
+        throw new Error('address input must be a string')
+      }
+
+      // Ensure the address is a BCH address.
+      const addr = this.slp.Address.toCashAddress(address)
+
+      // Get the UTXOs associated with the address.
+      const utxoData = await this.electrumx.utxo(addr)
+      // console.log(`utxoData: ${JSON.stringify(utxoData, null, 2)}`)
+      const utxos = utxoData.utxos
+
+      // Get SLP UTXOs from the psf-slp-indexer
+      const slpUtxoData = await this.psfSlpIndexer.balance(addr)
+      // console.log(`slpUtxoData: ${JSON.stringify(slpUtxoData, null, 2)}`)
+      const slpUtxos = slpUtxoData.balance.utxos
+
+      // Loop through the Fulcrum UTXOs.
+      for (let i = 0; i < utxos.length; i++) {
+        const thisUtxo = utxos[i]
+
+        // Loop through the UTXOs from psf-slp-indexer.
+        for (let j = 0; j < slpUtxos.length; j++) {
+          const thisSlpUtxo = slpUtxos[j]
+
+          // If the non-hydrated UTXO matches the SLP UTXO, then combine the data
+          // and mark the UTXO as an SLP token.
+          if (
+            thisUtxo.tx_hash === thisSlpUtxo.txid &&
+            thisUtxo.tx_pos === thisSlpUtxo.vout
+          ) {
+            thisUtxo.txid = thisUtxo.tx_hash
+            thisUtxo.vout = thisUtxo.tx_pos
+            thisUtxo.isSlp = true
+            thisUtxo.type = thisSlpUtxo.type
+            thisUtxo.qty = thisSlpUtxo.qty
+            thisUtxo.tokenId = thisSlpUtxo.tokenId
+            thisUtxo.address = thisSlpUtxo.address
+
+            break
+          }
+        }
+
+        // If there was no match, then this is a normal BCH UTXO. Mark it as such.
+        if (!thisUtxo.isSlp) {
+          thisUtxo.txid = thisUtxo.tx_hash
+          thisUtxo.vout = thisUtxo.tx_pos
+          thisUtxo.isSlp = false
+          thisUtxo.address = addr
+        }
+      }
+
+      // Get token UTXOs
+      let type1TokenUtxos = utxos.filter(
+        x => x.isSlp === true && x.type === 'token'
+      )
+
+      // Hydrate the UTXOs with additional token data.
+      type1TokenUtxos = await this.hydrateTokenData(type1TokenUtxos)
+
+      const bchUtxos = utxos.filter(x => x.isSlp === false)
+      const type1BatonUtxos = utxos.filter(
+        x => x.isSlp === true && x.type === 'baton'
+      )
+      const nullUtxos = utxos.filter(x => x.isSlp === null)
+
+      const outObj = {
+        address: addr,
+        bchUtxos,
+        slpUtxos: {
+          type1: {
+            tokens: type1TokenUtxos,
+            mintBatons: type1BatonUtxos
+          },
+          nft: {} // Allocated for future support of NFT spec.
+        },
+        nullUtxos
+      }
+
+      return outObj
+    } catch (err) {
+      // console.error('Error in bchjs.utxo.get2(): ', err)
+
+      if (err.error) throw new Error(err.error)
+      throw err
+    }
+  }
+
+  // Hydrate an array of token UTXOs with token information.
+  // Returns an array of token UTXOs with additional data.
+  async hydrateTokenData (utxoAry) {
+    try {
+      // console.log('utxoAry: ', utxoAry)
+
+      // Create a list of token IDs without duplicates.
+      let tokenIds = utxoAry.map(x => x.tokenId)
+
+      // Remove duplicates. https://stackoverflow.com/questions/9229645/remove-duplicate-values-from-js-array
+      tokenIds = [...new Set(tokenIds)]
+      // console.log('tokenIds: ', tokenIds)
+
+      // Get Genesis data for each tokenId
+      const genesisData = []
+      for (let i = 0; i < tokenIds.length; i++) {
+        const thisTokenId = tokenIds[i]
+        const thisTokenData = await this.psfSlpIndexer.tokenStats(thisTokenId)
+        // console.log('thisTokenData: ', thisTokenData)
+
+        genesisData.push(thisTokenData)
+      }
+      // console.log('genesisData: ', genesisData)
+
+      // Hydrate each token UTXO with data from the genesis transaction.
+      for (let i = 0; i < utxoAry.length; i++) {
+        const thisUtxo = utxoAry[i]
+
+        // Get the genesis data for this token.
+        const genData = genesisData.filter(
+          x => x.tokenData.tokenId === thisUtxo.tokenId
+        )
+        // console.log('genData: ', genData)
+
+        thisUtxo.ticker = genData[0].tokenData.ticker
+        thisUtxo.name = genData[0].tokenData.name
+        thisUtxo.documentUri = genData[0].tokenData.documentUri
+        thisUtxo.documentHash = genData[0].tokenData.documentHash
+        thisUtxo.decimals = genData[0].tokenData.decimals
+
+        // Calculate the real token quantity
+        const qty = new BigNumber(thisUtxo.qty).dividedBy(
+          10 ** parseInt(thisUtxo.decimals)
+        )
+        thisUtxo.qtyStr = qty.toString()
+      }
+
+      return utxoAry
+    } catch (err) {
+      console.log('Error in hydrateTokenData()')
+      throw err
+    }
+  }
+
   /**
    * @api Utxo.findBiggestUtxo() findBiggestUtxo()
    * @apiName findBiggestUtxo

package/test/integration/chains/bchn/psf-slp-indexer.integration.js

@@ -54,9 +54,9 @@ describe('#psf-slp-indexer', () => {
   })
 
   describe('#tx', () => {
-    it('should get hydrated tx data', async () => {
+    it('should get hydrated tx data for an SLP transaction', async () => {
       const txid =
-        '83361c34cac2ea7f9ca287fca57a96cc0763719f0cdf4850f9696c1e68eb635c'
+        '947ccb2a0d62ca287bc4b0993874ab0f9f6afd454193e631e2bf84dca66731fc'
 
       const result = await bchjs.PsfSlpIndexer.tx(txid)
       // console.log('result: ', result)
@@ -64,6 +64,53 @@ describe('#psf-slp-indexer', () => {
       assert.property(result.txData, 'vin')
       assert.property(result.txData, 'vout')
       assert.property(result.txData, 'isValidSlp')
+      assert.equal(result.txData.isValidSlp, true)
+    })
+
+    it('should mark non-SLP transaction as false', async () => {
+      const txid =
+        '03d6e6b63647ce7b02ecc73dc6d41b485be14a3e20eed4474b8a840358ddf14e'
+
+      const result = await bchjs.PsfSlpIndexer.tx(txid)
+      // console.log('result: ', result)
+
+      assert.property(result.txData, 'vin')
+      assert.property(result.txData, 'vout')
+      assert.property(result.txData, 'isValidSlp')
+      assert.equal(result.txData.isValidSlp, false)
+    })
+
+    // FlexUSD transactions
+    // Currently FlexUSD UTXOs are reported as invalid SLP UTXOs, which means
+    // the wallet will burn them. There is a TODO in the code. This test will
+    // need to be changed when it is done.
+    it('should mark blacklisted token as null', async () => {
+      const txid =
+        '302113c11b90edc5f36c073d2f8a75e1e0eaf59b56235491a843d3819cd6a85f'
+
+      const result = await bchjs.PsfSlpIndexer.tx(txid)
+      // console.log('result: ', result)
+
+      assert.property(result.txData, 'vin')
+      assert.property(result.txData, 'vout')
+      assert.property(result.txData, 'isValidSlp')
+      assert.equal(result.txData.isValidSlp, null)
+    })
+
+    it('should throw error for non-existent txid', async () => {
+      try {
+        const txid =
+          '302113c11b90edc5f36c073d2f8a75e1e0eaf59b56235491a843d3819cd6a85e'
+
+        await bchjs.PsfSlpIndexer.tx(txid)
+        // console.log('result: ', result)
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        // console.log(err)
+
+        assert.include(err.message, 'No such mempool or blockchain transaction')
+      }
     })
   })
 })