Merge pull request #145 from Permissionless-Software-Foundation/dh-v5-fulcrum-transactions

feat(txs): Created v5 Fulcrum /transactions endpoints in bch-api

package.json

@@ -24,8 +24,8 @@
     "coverage": "nyc report --reporter=text-lcov | coveralls",
     "coverage:report": "export NETWORK=mainnet && nyc --reporter=html mocha --timeout 25000 test/v4/",
     "docs": "./node_modules/.bin/apidoc -i src/routes/v4 -o docs",
-    "test:temp1": "export NETWORK=mainnet && export TEST=integration && mocha -g '#balanceBulk' --exit --timeout 30000 test/v5/",
-    "test:temp2": "export NETWORK=mainnet && mocha -g '#balanceBulk' --exit --timeout 30000 test/v5/"
+    "test:temp1": "export NETWORK=mainnet && export TEST=integration && mocha -g '#utxosBulk' --exit --timeout 30000 test/v5/",
+    "test:temp2": "export NETWORK=mainnet && mocha -g '#utxosBulk' --exit --timeout 30000 test/v5/"
   },
   "engines": {
     "node": ">=10.15.1"

test/v5/a01-electrumx.js

@@ -356,6 +356,997 @@ describe('#Electrumx', () => {
       assert.property(result.balances[0].balance, 'unconfirmed')
     })
   })
+  describe('#getUtxos', () => {
+    it('should throw 400 if address is empty', async () => {
+      const result = await electrumxRoute.getUtxos(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.equal(res.statusCode, 422, 'Expect 422 status code')
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'Unsupported address format')
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+    })
+
+    it('should throw 400 on array input', async () => {
+      req.params.address = ['qzs02v05l7qs5s24srqju498qu55dwuj0cx5ehjm2c']
+
+      const result = await electrumxRoute.getUtxos(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.equal(res.statusCode, 400, 'Expect 400 status code')
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'address can not be an array')
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+    })
+
+    it('should throw an error for an invalid address', async () => {
+      req.params.address = '02v05l7qs5s24srqju498qu55dwuj0cx5ehjm2c'
+
+      const result = await electrumxRoute.getUtxos(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.equal(res.statusCode, 422, 'Expect 422 status code')
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'Unsupported address format')
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+    })
+
+    it('should detect a network mismatch', async () => {
+      req.params.address = 'bchtest:qq89kjkeqz9mngp8kl3dpmu43y2wztdjqu500gn4c4'
+
+      const result = await electrumxRoute.getUtxos(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.equal(res.statusCode, 400, 'Expect 400 status code')
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'Invalid network', 'Proper error message')
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+    })
+
+    it('should pass errors from electrum-cash to user', async () => {
+      // Address has invalid checksum.
+      req.params.address =
+        'bitcoincash:qr69kyzha07dcecrsvjwsj4s6slnlq4r8c30lxnur2'
+
+      // Call the details API.
+      const result = await electrumxRoute.getUtxos(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'Unsupported address format')
+    })
+
+    it('should get utxos for a single address', async () => {
+      req.params.address =
+        'bitcoincash:qp3sn6vlwz28ntmf3wmyra7jqttfx7z6zgtkygjhc7'
+
+      // Mock unit tests to prevent live network calls.
+      if (process.env.TEST === 'unit') {
+        electrumxRoute.isReady = true // Force flag.
+
+        sandbox
+          .stub(electrumxRoute.axios, 'get')
+          .resolves({ data: { success: true, utxos: mockData.utxos } })
+      }
+
+      // Call the details API.
+      const result = await electrumxRoute.getUtxos(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.property(result, 'success')
+      assert.equal(result.success, true)
+
+      assert.property(result, 'utxos')
+      assert.isArray(result.utxos)
+
+      assert.property(result.utxos[0], 'height')
+      assert.property(result.utxos[0], 'tx_hash')
+      assert.property(result.utxos[0], 'tx_pos')
+      assert.property(result.utxos[0], 'value')
+    })
+  })
+
+  describe('#utxosBulk', () => {
+    it('should throw 400 if addresses is empty', async () => {
+      const result = await electrumxRoute.utxosBulk(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.equal(res.statusCode, 400, 'Expect 400 status code')
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'addresses needs to be an array')
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+    })
+
+    it('should throw 400 if input provided is not array', async () => {
+      req.body.addresses = 'qzs02v05l7qs5s24srqju498qu55dwuj0cx5ehjm2c'
+
+      const result = await electrumxRoute.utxosBulk(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.equal(res.statusCode, 400, 'Expect 400 status code')
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'addresses needs to be an array')
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+    })
+
+    it('should throw 400 error if addresses array is too large', async () => {
+      const testArray = []
+      for (var i = 0; i < 25; i++) testArray.push('')
+
+      req.body.addresses = testArray
+
+      const result = await electrumxRoute.utxosBulk(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'Array too large')
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+    })
+
+    it('should throw an error for an invalid address', async () => {
+      req.body.addresses = ['02v05l7qs5s24srqju498qu55dwuj0cx5ehjm2c']
+
+      const result = await electrumxRoute.utxosBulk(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.equal(res.statusCode, 400, 'Expect 400 status code')
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'Invalid BCH address')
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+    })
+
+    it('should detect a network mismatch', async () => {
+      req.body.addresses = [
+        'bchtest:qq89kjkeqz9mngp8kl3dpmu43y2wztdjqu500gn4c4'
+      ]
+
+      const result = await electrumxRoute.utxosBulk(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.equal(res.statusCode, 400, 'Expect 400 status code')
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'Invalid network', 'Proper error message')
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+    })
+
+    it('should pass errors from electrum-cash to user', async () => {
+      // Address has invalid checksum.
+      req.body.addresses = [
+        'bitcoincash:qr69kyzha07dcecrsvjwsj4s6slnlq4r8c30lxnur2'
+      ]
+
+      // Call the details API.
+      const result = await electrumxRoute.utxosBulk(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'Invalid BCH address')
+    })
+    it('should handle error', async () => {
+      req.body.addresses = [
+        'bitcoincash:qp3sn6vlwz28ntmf3wmyra7jqttfx7z6zgtkygjhc7',
+        'bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf'
+      ]
+      // Force error
+      sandbox.stub(electrumxRoute.axios, 'post').throws(new Error('Test error'))
+
+      // Call the details API.
+      const result = await electrumxRoute.utxosBulk(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'Test error')
+    })
+    it('should get utxos for an array of addresses', async () => {
+      req.body.addresses = [
+        'bitcoincash:qp3sn6vlwz28ntmf3wmyra7jqttfx7z6zgtkygjhc7',
+        'bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf'
+      ]
+
+      // Mock unit tests to prevent live network calls.
+      if (process.env.TEST === 'unit') {
+        electrumxRoute.isReady = true // Force flag.
+
+        sandbox
+          .stub(electrumxRoute.axios, 'post')
+          .resolves({ data: mockData.utxosArray })
+      }
+
+      // Call the details API.
+      const result = await electrumxRoute.utxosBulk(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.property(result, 'success')
+      assert.equal(result.success, true)
+
+      assert.property(result, 'utxos')
+      assert.property(result.utxos[0], 'utxos')
+      assert.property(result.utxos[0], 'address')
+
+      assert.isArray(result.utxos[0].utxos)
+      assert.isString(result.utxos[0].address)
+
+      const firtsAddrUtxos = result.utxos[0].utxos[0]
+      assert.property(firtsAddrUtxos, 'height')
+      assert.property(firtsAddrUtxos, 'tx_hash')
+      assert.property(firtsAddrUtxos, 'tx_pos')
+      assert.property(firtsAddrUtxos, 'value')
+    })
+  })
+
+  describe('#getTransactionDetails', () => {
+    it('should throw 400 if tx is empty', async () => {
+      const result = await electrumxRoute.getTransactionDetails(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.equal(res.statusCode, 400, 'Expect 400 status code')
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'txid must be a string')
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+    })
+
+    it('should throw 400 on array input', async () => {
+      req.params.txid = [
+        'a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d'
+      ]
+
+      const result = await electrumxRoute.getTransactionDetails(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.equal(res.statusCode, 400, 'Expect 400 status code')
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'txid must be a string')
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+    })
+
+    it('should pass errors from electrum-cash to user', async () => {
+      req.params.txid = '02v05l7qs5s24srqju498qu55dwuj0cx5ehjm2c'
+
+      const result = await electrumxRoute.getTransactionDetails(req, res)
+
+      assert.property(result, 'error')
+      assert.include(result.error.error, 'Invalid tx hash')
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+    })
+
+    it('should get details for a single tx', async () => {
+      req.params.txid =
+        'a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d'
+
+      // Mock unit tests to prevent live network calls.
+      if (process.env.TEST === 'unit') {
+        electrumxRoute.isReady = true // Force flag.
+
+        sandbox
+          .stub(electrumxRoute.axios, 'get')
+          .resolves({ data: { success: true, details: mockData.txDetails } })
+      }
+
+      // Call the details API.
+      const result = await electrumxRoute.getTransactionDetails(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.property(result, 'success')
+      assert.equal(result.success, true)
+
+      assert.property(result, 'details')
+      assert.property(result.details, 'blockhash')
+      assert.property(result.details, 'blocktime')
+      assert.property(result.details, 'confirmations')
+      assert.property(result.details, 'hash')
+      assert.property(result.details, 'hex')
+      assert.property(result.details, 'locktime')
+      assert.property(result.details, 'size')
+      assert.property(result.details, 'time')
+      assert.property(result.details, 'txid')
+      assert.property(result.details, 'version')
+      assert.property(result.details, 'vin')
+      assert.property(result.details, 'vout')
+    })
+  })
+
+  describe('#transactionDetailsBulk', () => {
+    it('should throw 400 if txids is empty', async () => {
+      const result = await electrumxRoute.transactionDetailsBulk(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.equal(res.statusCode, 400, 'Expect 400 status code')
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'txids needs to be an array')
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+    })
+
+    it('should throw 400 if input provided is not array', async () => {
+      req.body.txids =
+        'a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d'
+
+      const result = await electrumxRoute.transactionDetailsBulk(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.equal(res.statusCode, 400, 'Expect 400 status code')
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'txids needs to be an array')
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+    })
+
+    it('should throw 400 error if addresses array is too large', async () => {
+      const testArray = []
+      for (var i = 0; i < 25; i++) testArray.push('')
+
+      req.body.txids = testArray
+
+      const result = await electrumxRoute.transactionDetailsBulk(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'Array too large')
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+    })
+
+    it('should handle error', async () => {
+      req.body.txids = [
+        'a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d',
+        'a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d'
+      ]
+      // Force error
+      sandbox.stub(electrumxRoute.axios, 'post').throws(new Error('Test error'))
+
+      // Call the details API.
+      const result = await electrumxRoute.transactionDetailsBulk(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'Test error')
+    })
+
+    it('should get details for an array of tx', async () => {
+      req.body.txids = [
+        'a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d'
+      ]
+
+      // Mock unit tests to prevent live network calls.
+      if (process.env.TEST === 'unit') {
+        electrumxRoute.isReady = true // Force flag.
+
+        sandbox
+          .stub(electrumxRoute.axios, 'post')
+          .resolves({ data: mockData.txDetailsBulk })
+      }
+
+      // Call the details API.
+      const result = await electrumxRoute.transactionDetailsBulk(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.property(result, 'success')
+      assert.equal(result.success, true)
+
+      assert.property(result, 'transactions')
+      const tx = result.transactions[0]
+
+      assert.property(tx, 'details')
+      assert.property(tx.details, 'blockhash')
+      assert.property(tx.details, 'blocktime')
+      assert.property(tx.details, 'confirmations')
+      assert.property(tx.details, 'hash')
+      assert.property(tx.details, 'hex')
+      assert.property(tx.details, 'locktime')
+      assert.property(tx.details, 'size')
+      assert.property(tx.details, 'time')
+      assert.property(tx.details, 'txid')
+      assert.property(tx.details, 'version')
+      assert.property(tx.details, 'vin')
+      assert.property(tx.details, 'vout')
+    })
+  })
+
+  describe('#broadcastTransaction', () => {
+    it('should throw 400 if txHex is empty', async () => {
+      const result = await electrumxRoute.broadcastTransaction(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.equal(res.statusCode, 400, 'Expect 400 status code')
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'request body must be a string')
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+    })
+
+    it('should throw 400 on invalid input type', async () => {
+      req.body.txHex = [mockData.txDetails.hex]
+
+      const result = await electrumxRoute.broadcastTransaction(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.equal(res.statusCode, 400, 'Expect 400 status code')
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'request body must be a string')
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+    })
+
+    it('should pass errors from electrum-cash to user', async () => {
+      req.body.txHex = mockData.txDetails.hex.substring(10)
+      const result = await electrumxRoute.broadcastTransaction(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.equal(res.statusCode, 400, 'Expect 400 status code')
+
+      assert.property(result, 'error')
+      assert.include(result.error.error, 'the transaction was rejected')
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+    })
+
+    it('should broadcast transaction', async function () {
+      req.body.txHex = mockData.txDetails.hex
+
+      // Mock unit tests to prevent live network calls.
+      if (process.env.TEST === 'unit') {
+        electrumxRoute.isReady = true // Force flag.
+
+        sandbox
+          .stub(electrumxRoute.axios, 'post')
+          .resolves({ data: { success: true, txid: mockData.txDetails.hash } })
+      } else {
+        return this.skip()
+      }
+
+      // Call the details API.
+      const result = await electrumxRoute.broadcastTransaction(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.property(result, 'success')
+      assert.equal(result.success, true)
+
+      assert.property(result, 'txid')
+      assert.isString(result.txid)
+    })
+  })
+
+  describe('#getBlockHeaders', () => {
+    it('should throw 400 if height is empty', async () => {
+      const result = await electrumxRoute.getBlockHeaders(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.equal(res.statusCode, 400, 'Expect 400 status code')
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'height must be a positive number')
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+    })
+    it('should throw 400 if height is not a number', async () => {
+      req.params.height = 'wrong type'
+
+      const result = await electrumxRoute.getBlockHeaders(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.equal(res.statusCode, 400, 'Expect 400 status code')
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'height must be a positive number')
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+    })
+    it('should throw 400 if height is negative', async () => {
+      req.params.height = -1
+
+      const result = await electrumxRoute.getBlockHeaders(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.equal(res.statusCode, 400, 'Expect 400 status code')
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'height must be a positive number')
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+    })
+
+    it('should throw 400 if count is not a number', async () => {
+      req.params.height = 2
+      req.query.count = 'wrong type'
+
+      const result = await electrumxRoute.getBlockHeaders(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.equal(res.statusCode, 400, 'Expect 400 status code')
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'count must be a positive number')
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+    })
+
+    it('should throw 400 if count is negative', async () => {
+      req.params.height = 2
+      req.query.count = -1
+
+      const result = await electrumxRoute.getBlockHeaders(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.equal(res.statusCode, 400, 'Expect 400 status code')
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'count must be a positive number')
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+    })
+
+    it('should pass errors from electrum-cash to user', async () => {
+      req.params.height = 99999999999999
+      req.query.count = 99999999999999
+
+      // Mock unit tests to prevent live network calls.
+      if (process.env.TEST === 'unit') {
+        electrumxRoute.isReady = true // Force flag.
+
+        sandbox.stub(electrumxRoute.axios, 'get').resolves({
+          data: { success: false, error: { error: 'Invalid height' } }
+        })
+      }
+      // Call the details API.
+      const result = await electrumxRoute.getBlockHeaders(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+
+      assert.property(result, 'error')
+      assert.include(result.error.error, 'Invalid height')
+    })
+    it('should handle error', async () => {
+      req.params.height = 42
+      req.query.count = 2
+      // Force error
+      sandbox.stub(electrumxRoute.axios, 'get').throws(new Error('Test error'))
+
+      // Call the details API.
+      const result = await electrumxRoute.getBlockHeaders(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'Test error')
+    })
+
+    it('should get headers for a single block height with count 2', async () => {
+      req.params.height = 42
+      req.query.count = 2
+      // Mock unit tests to prevent live network calls.
+      if (process.env.TEST === 'unit') {
+        electrumxRoute.isReady = true // Force flag.
+
+        sandbox.stub(electrumxRoute.axios, 'get').resolves({
+          data: { success: true, headers: mockData.blockHeaders }
+        })
+      }
+
+      // Call the details API.
+      const result = await electrumxRoute.getBlockHeaders(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.property(result, 'success')
+      assert.equal(result.success, true)
+
+      assert.property(result, 'headers')
+      assert.isArray(result.headers)
+      assert.deepEqual(result.headers, mockData.blockHeaders)
+    })
+  })
+  describe('#blockHeadersBulk', () => {
+    it('should throw 400 for an empty body', async () => {
+      const result = await electrumxRoute.blockHeadersBulk(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.equal(res.statusCode, 400, 'Expect 400 status code')
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'heights needs to be an array')
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+    })
+
+    it('should NOT throw 400 error for an invalid height', async () => {
+      req.body = {
+        heights: [{ height: -10, count: 2 }]
+      }
+      if (process.env.TEST === 'unit') {
+        electrumxRoute.isReady = true // Force flag.
+
+        sandbox.stub(electrumxRoute.axios, 'post').resolves({
+          data: { success: true, headers: [{ headers: {} }] }
+        })
+      }
+      const result = await electrumxRoute.blockHeadersBulk(req, res)
+      console.log(`result: ${util.inspect(result)}`)
+
+      assert.equal(res.statusCode, 200, 'Expect 200 status code')
+
+      assert.property(result, 'success')
+      assert.equal(result.success, true)
+
+      assert.property(result, 'headers')
+      assert.isArray(result.headers)
+      assert.property(result.headers[0], 'headers')
+    })
+
+    it('should throw 400 error if heights array is too large', async () => {
+      const testArray = []
+      for (var i = 0; i < 25; i++) testArray.push('')
+
+      req.body.heights = testArray
+
+      const result = await electrumxRoute.blockHeadersBulk(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'Array too large')
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+    })
+
+    it('should handle error', async () => {
+      req.body = {
+        heights: [
+          { height: 42, count: 2 },
+          { height: 42, count: 2 }
+        ]
+      }
+
+      // Force error
+      sandbox.stub(electrumxRoute.axios, 'post').throws(new Error('Test error'))
+
+      // Call the details API.
+      const result = await electrumxRoute.blockHeadersBulk(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'Test error')
+    })
+    it('should get block heights', async () => {
+      req.body = {
+        heights: [
+          { height: 42, count: 2 },
+          { height: 42, count: 2 }
+        ]
+      }
+
+      // Mock unit tests to prevent live network calls.
+      if (process.env.TEST === 'unit') {
+        electrumxRoute.isReady = true // Force flag.
+        sandbox
+          .stub(electrumxRoute.axios, 'post')
+          .resolves({ data: mockData.blockHeadersBulk })
+      }
+
+      // Call the details API.
+      const result = await electrumxRoute.blockHeadersBulk(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.property(result, 'success')
+      assert.equal(result.success, true)
+
+      assert.property(result, 'headers')
+      assert.isArray(result.headers)
+      assert.property(result.headers[0], 'headers')
+    })
+  })
+  describe('#getTransactions', () => {
+    it('should throw 400 if address is empty', async () => {
+      const result = await electrumxRoute.getTransactions(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.equal(res.statusCode, 422, 'Expect 422 status code')
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'Unsupported address format')
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+    })
+
+    it('should throw 400 on array input', async () => {
+      req.params.address = ['qzs02v05l7qs5s24srqju498qu55dwuj0cx5ehjm2c']
+
+      const result = await electrumxRoute.getTransactions(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.equal(res.statusCode, 400, 'Expect 400 status code')
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'address can not be an array')
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+    })
+
+    it('should throw an error for an invalid address', async () => {
+      req.params.address = '02v05l7qs5s24srqju498qu55dwuj0cx5ehjm2c'
+
+      const result = await electrumxRoute.getTransactions(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.equal(res.statusCode, 422, 'Expect 422 status code')
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'Unsupported address format')
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+    })
+
+    it('should detect a network mismatch', async () => {
+      req.params.address = 'bchtest:qq89kjkeqz9mngp8kl3dpmu43y2wztdjqu500gn4c4'
+
+      const result = await electrumxRoute.getTransactions(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.equal(res.statusCode, 400, 'Expect 400 status code')
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'Invalid network', 'Proper error message')
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+    })
+
+    it('should pass errors from electrum-cash to user', async () => {
+      // Address has invalid checksum.
+      req.params.address =
+        'bitcoincash:qr69kyzha07dcecrsvjwsj4s6slnlq4r8c30lxnur2'
+
+      // Call the details API.
+      const result = await electrumxRoute.getTransactions(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'Unsupported address format')
+    })
+
+    it('should get transaction for a single address', async () => {
+      req.params.address =
+        'bitcoincash:qp3sn6vlwz28ntmf3wmyra7jqttfx7z6zgtkygjhc7'
+
+      // Mock unit tests to prevent live network calls.
+      if (process.env.TEST === 'unit') {
+        electrumxRoute.isReady = true // Force flag.
+
+        sandbox.stub(electrumxRoute.axios, 'get').resolves({
+          data: { success: true, transactions: mockData.transactions }
+        })
+      }
+
+      // Call the details API.
+      const result = await electrumxRoute.getTransactions(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.property(result, 'success')
+      assert.equal(result.success, true)
+
+      assert.property(result, 'transactions')
+      assert.isArray(result.transactions)
+
+      assert.property(result.transactions[0], 'height')
+      assert.property(result.transactions[0], 'tx_hash')
+    })
+  })
+  describe('#transactionsBulk', () => {
+    it('should throw 400 if addresses is empty', async () => {
+      const result = await electrumxRoute.transactionsBulk(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.equal(res.statusCode, 400, 'Expect 400 status code')
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'addresses needs to be an array')
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+    })
+
+    it('should throw 400 if input provided is not array', async () => {
+      req.body.addresses = 'qzs02v05l7qs5s24srqju498qu55dwuj0cx5ehjm2c'
+
+      const result = await electrumxRoute.transactionsBulk(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.equal(res.statusCode, 400, 'Expect 400 status code')
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'addresses needs to be an array')
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+    })
+
+    it('should throw 400 error if addresses array is too large', async () => {
+      const testArray = []
+      for (var i = 0; i < 25; i++) testArray.push('')
+
+      req.body.addresses = testArray
+
+      const result = await electrumxRoute.transactionsBulk(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'Array too large')
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+    })
+
+    it('should throw an error for an invalid address', async () => {
+      req.body.addresses = ['02v05l7qs5s24srqju498qu55dwuj0cx5ehjm2c']
+
+      const result = await electrumxRoute.transactionsBulk(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.equal(res.statusCode, 400, 'Expect 400 status code')
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'Invalid BCH address')
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+    })
+
+    it('should detect a network mismatch', async () => {
+      req.body.addresses = [
+        'bchtest:qq89kjkeqz9mngp8kl3dpmu43y2wztdjqu500gn4c4'
+      ]
+
+      const result = await electrumxRoute.transactionsBulk(req, res)
+      // console.log(`result: ${util.inspect(result)}`)
+
+      assert.equal(res.statusCode, 400, 'Expect 400 status code')
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'Invalid network', 'Proper error message')
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+    })
+
+    it('should pass errors from electrum-cash to user', async () => {
+      // Address has invalid checksum.
+      req.body.addresses = [
+        'bitcoincash:qr69kyzha07dcecrsvjwsj4s6slnlq4r8c30lxnur2'
+      ]
+
+      // Call the details API.
+      const result = await electrumxRoute.transactionsBulk(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'Invalid BCH address')
+    })
+    it('should handle error', async () => {
+      req.body.addresses = [
+        'bitcoincash:qp3sn6vlwz28ntmf3wmyra7jqttfx7z6zgtkygjhc7',
+        'bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf'
+      ]
+      // Force error
+      sandbox.stub(electrumxRoute.axios, 'post').throws(new Error('Test error'))
+
+      // Call the details API.
+      const result = await electrumxRoute.transactionsBulk(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.property(result, 'success')
+      assert.equal(result.success, false)
+
+      assert.property(result, 'error')
+      assert.include(result.error, 'Test error')
+    })
+    it('should get transaction for an array of addresses', async () => {
+      req.body.addresses = [
+        'bitcoincash:qp3sn6vlwz28ntmf3wmyra7jqttfx7z6zgtkygjhc7',
+        'bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf'
+      ]
+
+      // Mock unit tests to prevent live network calls.
+      if (process.env.TEST === 'unit') {
+        electrumxRoute.isReady = true // Force flag.
+
+        sandbox
+          .stub(electrumxRoute.axios, 'post')
+          .resolves({ data: mockData.transactionsBulk })
+      }
+
+      // Call the details API.
+      const result = await electrumxRoute.transactionsBulk(req, res)
+      // console.log(`result: ${JSON.stringify(result, null, 2)}`)
+
+      assert.property(result, 'success')
+      assert.equal(result.success, true)
+
+      assert.property(result, 'transactions')
+      assert.isArray(result.transactions)
+
+      assert.property(result.transactions[0], 'transactions')
+      assert.isArray(result.transactions[0].transactions)
+
+      assert.property(result.transactions[0].transactions[0], 'height')
+      assert.property(result.transactions[0].transactions[0], 'tx_hash')
+    })
+  })
 
   // describe('#_utxosFromElectrumx', () => {
   //   it('should throw error for invalid address', async () => {

test/v5/mocks/electrumx-mock.js

@@ -19,6 +19,43 @@ const utxos = [
   }
 ]
 
+const utxosArray = {
+  success: true,
+  utxos: [
+    {
+      utxos: [
+        {
+          height: 601861,
+          tx_hash:
+            '6181c669614fa18039a19b23eb06806bfece1f7514ab457c3bb82a40fe171a6d',
+          tx_pos: 0,
+          value: 1000
+        }
+      ],
+      address: 'bitcoincash:qp3sn6vlwz28ntmf3wmyra7jqttfx7z6zgtkygjhc7'
+    },
+    {
+      utxos: [
+        {
+          height: 604392,
+          tx_hash:
+            '7774e449c5a3065144cefbc4c0c21e6b69c987f095856778ef9f45ddd8ae1a41',
+          tx_pos: 0,
+          value: 1000
+        },
+        {
+          height: 630834,
+          tx_hash:
+            '4fe60a51e0d8f5134bfd8e5f872d6e502d7f01b28a6afebb27f4438a4f638d53',
+          tx_pos: 0,
+          value: 6000
+        }
+      ],
+      address: 'bitcoincash:qrdka2205f4hyukutc2g0s6lykperc8nsu5u2ddpqf'
+    }
+  ]
+}
+
 const balance = {
   success: true,
   balance: {
@@ -129,17 +166,56 @@ const txDetails = {
   ]
 }
 
+const txDetailsBulk = {
+  success: true,
+  transactions: [{ details: txDetails }]
+}
+
 const blockHeaders = [
   '010000008b52bbd72c2f49569059f559c1b1794de5192e4f7d6d2b03c7482bad0000000083e4f8a9d502ed0c419075c1abb5d56f878a2e9079e5612bfb76a2dc37d9c42741dd6849ffff001d2b909dd6',
   '01000000f528fac1bcb685d0cd6c792320af0300a5ce15d687c7149548904e31000000004e8985a786d864f21e9cbb7cbdf4bc9265fe681b7a0893ac55a8e919ce035c2f85de6849ffff001d385ccb7c'
 ]
 
+const blockHeadersBulk = {
+  success: true,
+  headers: [{ headers: blockHeaders }, { headers: blockHeaders }]
+}
+
+const transactions = [
+  {
+    height: 603416,
+    tx_hash: 'eef683d236d88e978bd406419f144057af3fe1b62ef59162941c1a9f05ded62c'
+  },
+  {
+    height: 646894,
+    tx_hash: '4c695fae636f3e8e2edc571d11756b880ccaae744390f3950d798ce7b5e25754'
+  }
+]
+
+const transactionsBulk = {
+  success: true,
+  transactions: [
+    {
+      transactions,
+      address: 'bitcoincash:qp3sn6vlwz28ntmf3wmyra7jqttfx7z6zgtkygjhc7'
+    },
+    {
+      transactions,
+      address: 'bitcoincash:qp3sn6vlwz28ntmf3wmyra7jqttfx7z6zgtkygjhc7'
+    }
+  ]
+}
 module.exports = {
   utxos,
+  utxosArray,
   balance,
   txHistory,
   mempool,
   txDetails,
+  txDetailsBulk,
   blockHeaders,
-  balances
+  blockHeadersBulk,
+  balances,
+  transactions,
+  transactionsBulk
 }