@psf/bch-js 4.20.27 → 4.22.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@psf/bch-js",
-  "version": "4.20.27",
+  "version": "4.22.1",
   "description": "The FullStack.cash JavaScript library for Bitcoin Cash and SLP Tokens",
   "author": "Chris Troutner <chris.troutner@gmail.com>",
   "contributors": [
@@ -14,12 +14,12 @@
     "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.0.36:3000/v5/ && mocha --timeout 30000 test/integration/ && mocha --timeout 30000 test/integration/chains/bchn/",
-    "test:integration:decatur:abc": "export RESTURL=http://192.168.0.38:3000/v5/ && mocha --timeout 30000 test/integration && mocha --timeout 30000 test/integration/chains/abc/",
+    "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: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/",
     "test:temp2": "mocha --timeout=30000 -g '#TransactionLib' test/unit/",

package/src/address.js

@@ -186,6 +186,21 @@ class Address {
     return cashAddress.split(':')[1]
   }
 
+  /**
+   * @api Address.toHash160() toHash160()
+   * @apiName toHash160
+   * @apiGroup Address
+   * @apiDescription Converts any address format to hash160
+   *
+   * @apiExample Example usage:
+   * // cash address mainnet p2pkh
+   * bchjs.Address.toHash160("bitcoincash:qptnmya5wkly7xf97wm5ak23yqdsz3l2cyj7k9vyyh")
+   * // 573d93b475be4f1925f3b74ed951201b0147eac1
+   *
+   * // cash address mainnet p2sh
+   * bchjs.Address.toHash160("bitcoincash:pp7ushdxf5we8mcpaa3wqgsuqt639cu59ur5xu5fug")
+   * // 7dc85da64d1d93ef01ef62e0221c02f512e3942f
+   */
   // Converts any address format to hash160
   toHash160 (address) {
     const legacyAddress = this.toLegacyAddress(address)

package/src/bch-js.js

@@ -33,10 +33,12 @@ const Encryption = require('./encryption')
 const Utxo = require('./utxo')
 const Transaction = require('./transaction')
 const DSProof = require('./dsproof')
+const Ecash = require('./ecash')
 
 // Indexers
 const Ninsight = require('./ninsight')
 const Electrumx = require('./electrumx')
+const PsfSlpIndexer = require('./psf-slp-indexer')
 
 class BCHJS {
   constructor (config) {
@@ -118,6 +120,9 @@ class BCHJS {
     this.Transaction = new Transaction(libConfig)
 
     this.DSProof = new DSProof(libConfig)
+    this.eCash = new Ecash()
+
+    this.PsfSlpIndexer = new PsfSlpIndexer(libConfig)
   }
 }
 

package/src/ecash.js

@@ -0,0 +1,47 @@
+/*
+  Utility library for converting units with eCash.
+*/
+
+class eCash {
+  /**
+   * @api eCash.toSatoshi() toSatoshi()
+   * @apiName toSatoshi
+   * @apiGroup eCash
+   * @apiDescription
+   * Convert XEC units into satoshi units
+   *
+   * @apiExample Example usage:
+   * // convert 10,704.35 XEC to satoshis:
+   * bchjs.eCash.toSatoshi(10704.35)
+   * // 1070435
+   */
+  toSatoshi (xec) {
+    if (typeof xec !== 'number') {
+      throw new Error('input must be a floating number representing XEC')
+    }
+
+    return Math.floor(xec * 100)
+  }
+
+  /**
+   * @api eCash.toXec() toXec()
+   * @apiName toXec
+   * @apiGroup eCash
+   * @apiDescription
+   * Convert satoshi units to XEC units
+   *
+   * @apiExample Example usage:
+   * // convert 1,070,435 satoshis to XEC:
+   * bchjs.eCash.toSatoshi(1070435)
+   * // 10704.35
+   */
+  toXec (sats) {
+    if (typeof sats !== 'number') {
+      throw new Error('input must be a floating number representing satoshis')
+    }
+
+    return sats / 100
+  }
+}
+
+module.exports = eCash

package/src/psf-slp-indexer.js

@@ -0,0 +1,292 @@
+/*
+  This library interacts with the PSF slp indexer REST API endpoints operated
+  by FullStack.cash
+*/
+// Public npm libraries
+const axios = require('axios')
+
+// let _this
+
+class PsfSlpIndexer {
+  constructor (config) {
+    this.restURL = config.restURL
+    this.apiToken = config.apiToken
+    this.authToken = config.authToken
+
+    if (this.authToken) {
+      // Add Basic Authentication token to the authorization header.
+      this.axiosOptions = {
+        headers: {
+          authorization: this.authToken
+        }
+      }
+    } else {
+      // Add JWT token to the authorization header.
+      this.axiosOptions = {
+        headers: {
+          authorization: `Token ${this.apiToken}`
+        }
+      }
+    }
+
+    // _this = this
+  }
+
+  /**
+   * @api PsfSlpIndexer.status()  status()
+   * @apiName Status
+   * @apiGroup PSF SLP
+   * @apiDescription Return status from psf slp indexer.
+   *
+   * @apiExample Example usage:
+   * (async () => {
+   *   try {
+   *     let status = await bchjs.PsfSlpIndexer.status();
+   *     console.log(status);
+   *   } catch(error) {
+   *    console.error(error)
+   *   }
+   * })()
+   *
+   *  {
+   *    "status": {
+   *      "startBlockHeight": 543376,
+   *      "syncedBlockHeight": 723249,
+   *      "chainBlockHeight": 722679
+   *     }
+   *  }
+   *
+   */
+  async status () {
+    try {
+      const response = await axios.get(
+        `${this.restURL}psf/slp/status`,
+        this.axiosOptions
+      )
+      return response.data
+    } catch (error) {
+      if (error.response && error.response.data) throw error.response.data
+      else throw error
+    }
+  }
+
+  /**
+   * @api PsfSlpIndexer.balance()  balance()
+   * @apiName SLP Balance
+   * @apiGroup PSF SLP
+   * @apiDescription Return slp balance for a single address.
+   *
+   * @apiExample Example usage:
+   * (async () => {
+   *   try {
+   *     let balance = await bchjs.PsfSlpIndexer.balance('bitcoincash:qzmd5vxgh9m22m6fgvm57yd6kjnjl9qnwywsf3583n');
+   *     console.log(balance);
+   *   } catch(error) {
+   *    console.error(error)
+   *   }
+   * })()
+   *
+   *  {
+   *    balance: {
+   *      utxos: [
+   *        {
+   *          txid: 'a24a6a4abf06fabd799ecea4f8fac6a9ff21e6a8dd6169a3c2ebc03665329db9',
+   *          vout: 1,
+   *          type: 'token',
+   *          qty: '1800',
+   *          tokenId: 'a4fb5c2da1aa064e25018a43f9165040071d9e984ba190c222a7f59053af84b2',
+   *          address: 'bitcoincash:qrqy3kj7r822ps6628vwqq5k8hyjl6ey3y4eea2m4s'
+   *        }
+   *      ],
+   *      txs: [
+   *        {
+   *          txid: '078b2c48ed1db0d5d5996f2889b8d847a49200d0a781f6aa6752f740f312688f',
+   *          height: 717796
+   *        },
+   *        {
+   *          txid: 'a24a6a4abf06fabd799ecea4f8fac6a9ff21e6a8dd6169a3c2ebc03665329db9',
+   *          height: 717832
+   *        }
+   *      ],
+   *      balances: [
+   *        {
+   *          tokenId: 'a4fb5c2da1aa064e25018a43f9165040071d9e984ba190c222a7f59053af84b2',
+   *          qty: '1800'
+   *        }
+   *      ]
+   *    }
+   *  }
+   *
+   */
+  async balance (address) {
+    try {
+      // Handle single address.
+      if (typeof address === 'string') {
+        const response = await axios.post(
+          `${this.restURL}psf/slp/address`,
+          { address },
+          this.axiosOptions
+        )
+        return response.data
+      }
+      throw new Error('Input address must be a string.')
+    } catch (error) {
+      if (error.response && error.response.data) throw error.response.data
+      else throw error
+    }
+  }
+
+  /**
+   * @api PsfSlpIndexer.tokenStats()  tokenStats()
+   * @apiName Token Stats
+   * @apiGroup PSF SLP
+   * @apiDescription Return list stats for a single slp token.
+   *
+   * @apiExample Example usage:
+   * (async () => {
+   *   try {
+   *     let tokenStats = await bchjs.PsfSlpIndexer.tokenStats('a4fb5c2da1aa064e25018a43f9165040071d9e984ba190c222a7f59053af84b2');
+   *     console.log(tokenStats);
+   *   } catch(error) {
+   *    console.error(error)
+   *   }
+   * })()
+   *
+   * {
+   *   tokenData: {
+   *     type: 1,
+   *     ticker: 'TROUT',
+   *     name: "Trout's test token",
+   *     tokenId: 'a4fb5c2da1aa064e25018a43f9165040071d9e984ba190c222a7f59053af84b2',
+   *     documentUri: 'troutsblog.com',
+   *     documentHash: '',
+   *     decimals: 2,
+   *     mintBatonIsActive: true,
+   *     tokensInCirculationBN: '100098953386',
+   *     tokensInCirculationStr: '100098953386',
+   *     blockCreated: 622414,
+   *     totalBurned: '1046614',
+   *     totalMinted: '100100000000'
+   *     txs: [
+   *       {
+   *         txid: 'a4fb5c2da1aa064e25018a43f9165040071d9e984ba190c222a7f59053af84b2',
+   *         height: 622414,
+   *         type: 'GENESIS',
+   *         qty: '100000000000'
+   *       }
+   *     ]
+   *   }
+   * }
+   *
+   */
+
+  async tokenStats (tokenId) {
+    try {
+      // Handle single address.
+      if (typeof tokenId === 'string') {
+        const response = await axios.post(
+          `${this.restURL}psf/slp/token`,
+          { tokenId },
+          this.axiosOptions
+        )
+        return response.data
+      }
+      throw new Error('Input tokenId must be a string.')
+    } catch (error) {
+      if (error.response && error.response.data) throw error.response.data
+      else throw error
+    }
+  }
+
+  /**
+   * @api PsfSlpIndexer.tx()  tx()
+   * @apiName SLP Transaction Data
+   * @apiGroup PSF SLP
+   * @apiDescription Return slp transaction data.
+   *
+   * @apiExample Example usage:
+   * (async () => {
+   *   try {
+   *     let txData = await bchjs.PsfSlpIndexer.tx('a4fb5c2da1aa064e25018a43f9165040071d9e984ba190c222a7f59053af84b2');
+   *     console.log(txData);
+   *   } catch(error) {
+   *    console.error(error)
+   *   }
+   * })()
+   *
+   * {
+   *   txData: {
+   *     txid: 'a4fb5c2da1aa064e25018a43f9165040071d9e984ba190c222a7f59053af84b2',
+   *     hash: 'a4fb5c2da1aa064e25018a43f9165040071d9e984ba190c222a7f59053af84b2',
+   *     version: 2,
+   *     size: 339,
+   *     locktime: 0,
+   *     vin: [
+   *       {
+   *         txid: '8370db30d94761ab9a11b71ecd22541151bf6125c8c613f0f6fab8ab794565a7',
+   *         vout: 0,
+   *         scriptSig: {
+   *           asm: '304402207e9631c53dfc8a9a793d1916469628c6b7c5780c01c2f676d51ef21b0ba4926f022069feb471ec869a49f8d108d0aaba04e7cd36e60a7500109d86537f55698930d4[ALL|FORKID] 02791b19a39165dbd83403d6df268d44fd621da30581b0b6e5cb15a7101ed58851',
+   *           hex: '47304402207e9631c53dfc8a9a793d1916469628c6b7c5780c01c2f676d51ef21b0ba4926f022069feb471ec869a49f8d108d0aaba04e7cd36e60a7500109d86537f55698930d4412102791b19a39165dbd83403d6df268d44fd621da30581b0b6e5cb15a7101ed58851'
+   *         },
+   *         sequence: 4294967295,
+   *         address: 'bitcoincash:qpvsg9vl9a5mlf37a7n3yce6pktdctn73qwgaqm3wq',
+   *         value: 0.00051303,
+   *         tokenQty: 0,
+   *         tokenQtyStr: '0',
+   *         tokenId: null
+   *       }
+   *     ],
+   *     vout: [
+   *       {
+   *         value: 0,
+   *         n: 0,
+   *         scriptPubKey: {
+   *           asm: 'OP_RETURN 5262419 1 47454e45534953 54524f5554 54726f75742773207465737420746f6b656e 74726f757473626c6f672e636f6d 0 2 2 000000174876e800',
+   *           hex: '6a04534c500001010747454e455349530554524f55541254726f75742773207465737420746f6b656e0e74726f757473626c6f672e636f6d4c000102010208000000174876e800',
+   *           type: 'nulldata'
+   *         },
+   *         tokenQtyStr: '0',
+   *         tokenQty: 0
+   *       }
+   *     ],
+   *     hex: '0200000001a7654579abb8faf6f013c6c82561bf51115422cd1eb7119aab6147d930db7083000000006a47304402207e9631c53dfc8a9a793d1916469628c6b7c5780c01c2f676d51ef21b0ba4926f022069feb471ec869a49f8d108d0aaba04e7cd36e60a7500109d86537f55698930d4412102791b19a39165dbd83403d6df268d44fd621da30581b0b6e5cb15a7101ed58851ffffffff040000000000000000476a04534c500001010747454e455349530554524f55541254726f75742773207465737420746f6b656e0e74726f757473626c6f672e636f6d4c000102010208000000174876e80022020000000000001976a914db4d39ceb7794ffe5d06855f249e1d3a7f1b024088ac22020000000000001976a914db4d39ceb7794ffe5d06855f249e1d3a7f1b024088accec20000000000001976a9145904159f2f69bfa63eefa712633a0d96dc2e7e8888ac00000000',
+   *     blockhash: '0000000000000000009f65225a3e12e23a7ea057c869047e0f36563a1f410267',
+   *     confirmations: 97398,
+   *     time: 1581773131,
+   *     blocktime: 1581773131,
+   *     blockheight: 622414,
+   *     isSlpTx: true,
+   *     tokenTxType: 'GENESIS',
+   *     tokenId: 'a4fb5c2da1aa064e25018a43f9165040071d9e984ba190c222a7f59053af84b2',
+   *     tokenType: 1,
+   *     tokenTicker: 'TROUT',
+   *     tokenName: "Trout's test token",
+   *     tokenDecimals: 2,
+   *     tokenUri: 'troutsblog.com',
+   *     tokenDocHash: '',
+   *     isValidSlp: true
+   *   }
+   * }
+   *
+   */
+  async tx (txid) {
+    try {
+      // Handle single address.
+      if (typeof txid === 'string') {
+        const response = await axios.post(
+          `${this.restURL}psf/slp/txid`,
+          { txid },
+          this.axiosOptions
+        )
+        return response.data
+      }
+      throw new Error('Input txid must be a string.')
+    } catch (error) {
+      if (error.response && error.response.data) throw error.response.data
+      else throw error
+    }
+  }
+}
+
+module.exports = PsfSlpIndexer

package/src/slp/address.js

@@ -36,7 +36,7 @@ class Address extends BCHJSAddress {
    *  bchjs.SLP.Address.toSLPAddress('qzm47qz5ue99y9yl4aca7jnz7dwgdenl85jkfx3znl')
    *  // simpleledger:qzm47qz5ue99y9yl4aca7jnz7dwgdenl857dzayzdp
    *
-   *  // tesnet legacy
+   *  // testnet legacy
    *  bchjs.SLP.Address.toSLPAddress('msDbtTj7kWXPpYaR7PQmMK84i66fJqQMLx')
    *  // slptest:qzq9je6pntpva3wf6scr7mlnycr54sjgeqauyclpwv
    *

package/src/utxo.js

@@ -183,6 +183,10 @@ class UTXO {
    */
   async get (address, useWhitelist = false) {
     try {
+      if (!address) {
+        throw new Error('Address must be an array or a string')
+      }
+
       // Convert address to an array if it is a string.
       if (typeof address === 'string') address = [address]
 

package/test/integration/blockchain.js

@@ -313,6 +313,14 @@ describe('#blockchain', () => {
       assert.isString(result)
     })
   })
+
+  describe('#getBlockchainInfo', () => {
+    it('should get info about the blockchain', async () => {
+      const result = await bchjs.Blockchain.getBlockchainInfo()
+
+      console.log(`blockchain info: ${JSON.stringify(result, null, 2)}`)
+    })
+  })
 })
 
 function sleep (ms) {

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

@@ -0,0 +1,74 @@
+/*
+  Integration tests for the psf-slp-indexer.js library
+*/
+
+const assert = require('chai').assert
+
+const BCHJS = require('../../../../src/bch-js')
+let bchjs
+
+describe('#psf-slp-indexer', () => {
+  beforeEach(async () => {
+    // Introduce a delay so that the BVT doesn't trip the rate limits.
+    if (process.env.IS_USING_FREE_TIER) await sleep(3000)
+
+    bchjs = new BCHJS()
+  })
+
+  describe('#status', () => {
+    it('should return the status of the indexer.', async () => {
+      const result = await bchjs.PsfSlpIndexer.status()
+      // console.log('result: ', result)
+
+      assert.property(result.status, 'startBlockHeight')
+      assert.property(result.status, 'syncedBlockHeight')
+      assert.property(result.status, 'chainBlockHeight')
+    })
+  })
+
+  describe('#balance', () => {
+    it('should get balance data for an address.', async () => {
+      const addr = 'bitcoincash:qzmd5vxgh9m22m6fgvm57yd6kjnjl9qnwywsf3583n'
+
+      const result = await bchjs.PsfSlpIndexer.balance(addr)
+      // console.log('result: ', result)
+
+      assert.property(result.balance, 'utxos')
+      assert.property(result.balance, 'txs')
+      assert.property(result.balance, 'balances')
+    })
+  })
+
+  describe('#tokenStats', () => {
+    it('should get stats on a token', async () => {
+      const tokenId =
+        '38e97c5d7d3585a2cbf3f9580c82ca33985f9cb0845d4dcce220cb709f9538b0'
+
+      const result = await bchjs.PsfSlpIndexer.tokenStats(tokenId)
+      // console.log('result: ', result)
+
+      assert.property(result.tokenData, 'documentUri')
+      assert.property(result.tokenData, 'txs')
+      assert.property(result.tokenData, 'totalBurned')
+    })
+  })
+
+  describe('#tx', () => {
+    it('should get hydrated tx data', async () => {
+      const txid =
+        '83361c34cac2ea7f9ca287fca57a96cc0763719f0cdf4850f9696c1e68eb635c'
+
+      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')
+    })
+  })
+})
+
+// Promise-based sleep function
+function sleep (ms) {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}