@tchain/tcabci-read-js-client 2.2.4 → 2.4.0

package/README.md

@@ -4,6 +4,11 @@ TransferChain Fastest Read Network WebSocket Client
 Read Node Address: [https://read-node-01.transferchain.io](https://read-node-01.transferchain.io)
 Read Node WebSocket Address: [wss://read-node-01.transferchain.io/ws](wss://read-node-01.transferchain.io/ws)
 
+## Networks
+
+- transferchain - v1
+- medusa - v2 (new blocks)
+
 ## Installation
 
 ```shell
@@ -23,6 +28,17 @@ const client = new TCaBCIClient([
   'https://read-node-01.transferchain.io',
   'wss://read-node-01.transferchain.io/ws',
 ])
+// OR
+// With addresses and WebSocket library and network name, version
+const client = new TCaBCIClient(
+  [
+    'https://read-node-01.transferchain.io',
+    'wss://read-node-01.transferchain.io/ws',
+  ],
+  WebSocket,
+  'transferchain',
+  'v1',
+)
 
 client.Start()
 

package/client.js

@@ -18,8 +18,7 @@ import {
   TX_TYPE,
 } from './constants.js'
 import Message from './message.js'
-import { toJSON } from './util.js'
-
+import { isJSON, toJSON } from './util.js'
 
 /**
  * @callback successCallback
@@ -44,8 +43,11 @@ import { toJSON } from './util.js'
 export default class TCaBCIClient {
   subscribed = false
   subscribedAddresses = []
+  subscribedSignedData = {}
   connected = false
-  version = 'v2.2.4'
+  chainName = 'transferchain'
+  chainVersion = 'v1'
+  version = 'v2.4.0'
   /**
    * @type {?successCallback}
    */
@@ -70,18 +72,30 @@ export default class TCaBCIClient {
   /**
    * @param {Array<String>} readNodeAddresses
    * @param {WebSocket} wsLibrary
+   * @param {?string} chainName
+   * @param {?string} chainVersion
    */
-  constructor(readNodeAddresses = [], wsLibrary) {
-    if (!wsLibrary) throw INVALID_ARGUMENTS
+  constructor(
+    readNodeAddresses = [],
+    wsLibrary,
+    chainName = null,
+    chainVersion = null,
+  ) {
+    if (!wsLibrary) throw new Error(INVALID_ARGUMENTS)
     this.wsLibrary = wsLibrary
 
     if (Array.isArray(readNodeAddresses) && readNodeAddresses.length === 2) {
       this.readNodeAddress = readNodeAddresses[0]
       this.readNodeWSAddress = readNodeAddresses[1]
 
-      if (!readNodeAddresses[0].startsWith('http')) throw INVALID_ARGUMENTS
-      if (!readNodeAddresses[1].startsWith('ws')) throw INVALID_ARGUMENTS
+      if (!readNodeAddresses[0].startsWith('http'))
+        throw new Error(INVALID_ARGUMENTS)
+      if (!readNodeAddresses[1].startsWith('ws'))
+        throw new Error(INVALID_ARGUMENTS)
     }
+
+    if (chainName) this.chainName = chainName
+    if (chainVersion) this.chainVersion = chainVersion
   }
 
   /**
@@ -154,9 +168,13 @@ export default class TCaBCIClient {
     return this.connect()
   }
 
+  /**
+   * @return {TCaBCIClient}
+   * @throws {Error}
+   */
   Stop() {
     if (!this.getConnected()) {
-      throw NOT_CONNECTED
+      throw new Error(NOT_CONNECTED)
     }
     this.Disconnect(1000)
     this.setConnected(false)
@@ -165,30 +183,42 @@ export default class TCaBCIClient {
     return this
   }
 
-  Subscribe(addresses = [], txTypes = []) {
+  /**
+   * @param {Array<string>} addresses
+   * @param {Object} signedData
+   * @param {?Array<string>} txTypes
+   * @return {TCaBCIClient}
+   */
+  Subscribe(addresses, signedData, txTypes = null) {
     if (!Array.isArray(addresses)) {
-      throw INVALID_ARGUMENTS
+      throw new Error(INVALID_ARGUMENTS)
+    }
+
+    if (typeof signedData !== 'object') {
+      throw new Error(INVALID_ARGUMENTS)
     }
 
     if (txTypes && !Array.isArray(addresses)) {
-      throw INVALID_ARGUMENTS
+      throw new Error(INVALID_ARGUMENTS)
     }
 
-    if (txTypes.length && txTypes.length > Object.values(TX_TYPE).length) {
-      throw INVALID_ARGUMENTS
+    if (txTypes && txTypes.length > Object.values(TX_TYPE).length) {
+      throw new Error(INVALID_ARGUMENTS)
     }
 
     if (!this.getConnected()) {
-      throw NOT_CONNECTED
+      throw new Error(NOT_CONNECTED)
     }
 
-    let addrs = []
+    let addrs = [],
+      sdata = {}
 
     if (addresses.length === 0) {
-      throw ADDRESSES_IS_EMPTY
+      throw new Error(ADDRESSES_IS_EMPTY)
     }
 
     addrs = addresses
+    sdata = signedData
 
     if (this.getSubscribeAddresses().length > 0) {
       let newAddress = []
@@ -201,47 +231,74 @@ export default class TCaBCIClient {
       addrs = newAddress
     }
 
-    const message = new Message(true, MESSAGE_TYPE.SUBSCRIBE, addrs, txTypes)
+    if (this.getSubscribedSignedData().length > 0) {
+      sdata = this.getSubscribedSignedData()
+    }
+
+    const message = new Message(
+      true,
+      MESSAGE_TYPE.SUBSCRIBE,
+      addrs,
+      sdata,
+      txTypes,
+    )
 
-    this.ws.send(message.ToJSONString())
+    this.ws.send(message.ToJSON())
     this.setSubscribeAddresses(addrs, true)
-    this.setSubscribed(true)
+      .setSubscribeSignedData(signedData)
+      .setSubscribed(true)
+
+    return this
   }
 
   Unsubscribe() {
     if (!this.getSubscribed()) {
-      throw NOT_SUBSCRIBED
+      throw new Error(NOT_SUBSCRIBED)
     }
     this.ws.send(
       new Message(
         true,
         MESSAGE_TYPE.UNSUBSCRIBE,
         this.getSubscribeAddresses(),
-      ).ToJSONString(),
+      ).ToJSON(),
     )
     this.setSubscribed(false)
     this.setSubscribeAddresses([])
+    this.setSubscribeSignedData({})
   }
 
   /**
+   * @param {?string} chainName
+   * @param {?string} chainVersion
    * @return {Promise<any>}
    */
-  LastBlock() {
-    return this.httpClient('/v1/blocks?limit=1&offset=0', {
-      method: 'GET',
-    })
+  LastBlock(chainName = null, chainVersion = null) {
+    return this.httpClient(
+      `/v1/blocks?chain_name=${chainName ?? this.chainName}&chain_version=${chainVersion ?? this.chainVersion}&limit=1&offset=0`,
+      {
+        method: 'GET',
+      },
+    )
       .then((res) => {
         return { blocks: res.data, total_count: res.total_count }
       })
-      .catch((e) => this.handleRestError(e, BLOCK_NOT_FOUND))
+      .catch((e) => this.handleRestError(e, new Error(BLOCK_NOT_FOUND)))
   }
 
-  Tx(id) {
+  /**
+   * @param {string} id
+   * @param {string} signature
+   * @return {Promise<*>}
+   */
+  Tx(id, signature) {
     if (!id || typeof id !== 'string') {
-      return Promise.reject(INVALID_ARGUMENTS)
+      return Promise.reject(new Error(INVALID_ARGUMENTS))
     }
 
-    return this.httpClient(`/v1/tx/${id}`, { method: 'GET' })
+    return this.httpClient(`/v1/tx/${id}`, {
+      method: 'GET',
+      headers: { 'X-Signature': signature },
+    })
       .then((res) => {
         return { tx: res.data }
       })
@@ -251,25 +308,41 @@ export default class TCaBCIClient {
   /**
    * @param {?Array<string>} recipientAddrs
    * @param {?Array<string>} senderAddrs
+   * @param {?Object} signedData
    * @param {?string} typ
-   * @param {?Array<string>}
+   * @param {?Array<string>} types
+   * @param {?string} chainName
+   * @param {?string} chainVersion
    * @return {Promise<any>}
    */
-  TxSummary({ recipientAddrs, senderAddrs, typ, types }) {
+  TxSummary({
+    recipientAddrs,
+    senderAddrs,
+    signedData,
+    typ,
+    types = null,
+    chainName = null,
+    chainVersion = null,
+  }) {
     if (!recipientAddrs && !senderAddrs) {
-      return Promise.reject(INVALID_ARGUMENTS)
+      return Promise.reject(new Error(INVALID_ARGUMENTS))
     }
 
     return this.httpClient('/v1/tx_summary', {
       method: 'POST',
       body: JSON.stringify({
+        chain_name: chainName ?? this.chainName,
+        chain_version: chainVersion ?? this.chainVersion,
         recipient_addrs: recipientAddrs,
         sender_addrs: senderAddrs,
+        signed_addrs: signedData,
         ...(types ? { types: types } : { typ: typ }),
       }),
     })
       .then((res) => {
         return {
+          chain_name: res.data.chain_name,
+          chain_version: res.data.chain_version,
           first_block_height: res.data.first_block_height,
           first_transaction: res.data.first_transaction,
           last_block_height: res.data.last_block_height,
@@ -287,6 +360,7 @@ export default class TCaBCIClient {
    * @param {?number} lastOrder
    * @param {?Array<string>} recipientAddrs
    * @param {?Array<string>} senderAddrs
+   * @param {?Object} signedData
    * @param {?Array<string>} hashes
    * @param {string} typ
    * @param {?Array<string>} types
@@ -294,6 +368,8 @@ export default class TCaBCIClient {
    * @param {number} offset
    * @param {string} orderField
    * @param {string} orderBy
+   * @param {?string} chainName
+   * @param {?string} chainVersion
    * @return {Promise<any>}
    */
   TxSearch({
@@ -303,6 +379,7 @@ export default class TCaBCIClient {
     lastOrder,
     recipientAddrs,
     senderAddrs,
+    signedData,
     hashes,
     typ,
     types,
@@ -310,15 +387,20 @@ export default class TCaBCIClient {
     offset,
     orderField,
     orderBy,
+    chainName = null,
+    chainVersion = null,
   }) {
     return this.httpClient('/v1/tx_search/p', {
       method: 'POST',
       body: JSON.stringify({
+        chain_name: chainName ?? this.chainName,
+        chain_version: chainVersion ?? this.chainVersion,
         height: `${heightOperator} ${height}`,
         ...(maxHeight ? { max_height: maxHeight } : {}),
         ...(lastOrder ? { last_order: lastOrder } : {}),
         ...(recipientAddrs ? { recipient_addrs: recipientAddrs } : {}),
         ...(senderAddrs ? { sender_addrs: senderAddrs } : {}),
+        ...(signedData ? { signed_addrs: signedData } : {}),
         ...(hashes ? { hashes: hashes } : {}),
         ...(limit ? { limit: limit } : {}),
         ...(offset ? { offset: offset } : {}),
@@ -338,6 +420,8 @@ export default class TCaBCIClient {
 
   Status() {
     return {
+      chain_name: this.chainName,
+      chain_version: this.chainVersion,
       connected: this.connected,
       subscribed: this.subscribed,
     }
@@ -354,7 +438,7 @@ export default class TCaBCIClient {
    * @param {number} fee
    * @return {Promise<any>}
    */
-  Broadcast({
+  BroadcastCommit({
     id,
     version,
     type,
@@ -364,13 +448,45 @@ export default class TCaBCIClient {
     sign,
     fee,
   }) {
-    if (Object.values(TX_TYPE).indexOf(type) < 0) {
-      throw TRANSACTION_TYPE_NOT_VALID
-    }
+    return this.broadcast(
+      {
+        id,
+        version,
+        type,
+        data,
+        sender_addr,
+        recipient_addr,
+        sign,
+        fee,
+      },
+      false,
+      true,
+    )
+  }
 
-    return this.httpClient('/v1/tx', {
-      method: 'POST',
-      body: JSON.stringify({
+  /**
+   * @param {string} id
+   * @param {number} version
+   * @param {string} type
+   * @param {string} data
+   * @param {string} sender_addr
+   * @param {string} recipient_addr
+   * @param {string} sign
+   * @param {number} fee
+   * @return {Promise<any>}
+   */
+  BroadcastSync({
+    id,
+    version,
+    type,
+    data,
+    sender_addr,
+    recipient_addr,
+    sign,
+    fee,
+  }) {
+    return this.broadcast(
+      {
         id,
         version,
         type,
@@ -379,25 +495,105 @@ export default class TCaBCIClient {
         recipient_addr,
         sign,
         fee,
-      }),
-    })
+      },
+      true,
+      false,
+    )
+  }
+
+  /**
+   * @param {string} id
+   * @param {number} version
+   * @param {string} type
+   * @param {string} data
+   * @param {string} sender_addr
+   * @param {string} recipient_addr
+   * @param {string} sign
+   * @param {number} fee
+   * @return {Promise<any>}
+   */
+  Broadcast({
+    id,
+    version,
+    type,
+    data,
+    sender_addr,
+    recipient_addr,
+    sign,
+    fee,
+  }) {
+    return this.broadcast(
+      {
+        id,
+        version,
+        type,
+        data,
+        sender_addr,
+        recipient_addr,
+        sign,
+        fee,
+      },
+      false,
+      false,
+    )
+  }
+
+  broadcast(
+    { id, version, type, data, sender_addr, recipient_addr, sign, fee },
+    sync = false,
+    commit = false,
+  ) {
+    if (Object.values(TX_TYPE).indexOf(type) < 0) {
+      throw new Error(TRANSACTION_TYPE_NOT_VALID)
+    }
+
+    return this.httpClient(
+      commit ? '/v1/tx/commit' : sync ? '/v1/tx/sync' : '/v1/tx',
+      {
+        method: 'POST',
+        body: JSON.stringify({
+          id,
+          version,
+          type,
+          data,
+          sender_addr,
+          recipient_addr,
+          sign,
+          fee,
+        }),
+      },
+    )
       .then((res) => {
         return { data: res.data }
       })
-      .catch((e) => this.handleRestError(e, { 400: TRANSACTION_NOT_BROADCAST }))
+      .catch((e) =>
+        this.handleRestError(e, { 400: new Error(TRANSACTION_NOT_BROADCAST) }),
+      )
   }
 
   /**
    * @param {Array<string>} addresses
+   * @param {Object} signedData
    * @param {?number} maxHeight
+   * @param {?string} chainName
+   * @param {?string} chainVersion
    * @return {Promise<*>}
    * @constructor
    */
-  Bulk(addresses = [], maxHeight = null) {
+  Bulk(
+    addresses = [],
+    signedData = {},
+    maxHeight = null,
+    chainName = null,
+    chainVersion = null,
+  ) {
     return this.httpClient('/v1/bulk_tx', {
       method: 'POST',
       body: JSON.stringify({
+        chain_name: chainName ?? this.chainName,
+        chain_version: chainVersion ?? this.chainVersion,
         addresses: addresses,
+        signed_addrs: signedData,
         ...(maxHeight ? { max_height: maxHeight } : {}),
       }),
     })
@@ -433,13 +629,12 @@ export default class TCaBCIClient {
     if (this.listenCb) this.listenCb(message)
   }
 
-
   /**
    * @return {Promise<Event>}
    */
   async connect() {
     if (this.getConnected()) {
-      return Promise.reject(ALREADY_CONNECTED)
+      return Promise.reject(new Error(ALREADY_CONNECTED))
     }
 
     const options = {
@@ -455,6 +650,7 @@ export default class TCaBCIClient {
         this.setConnected(false)
         this.setSubscribed(false)
         this.setSubscribeAddresses([], false)
+        this.setSubscribeSignedData({})
         this.callErrorCallback(event)
 
         reject(event)
@@ -470,12 +666,13 @@ export default class TCaBCIClient {
           return { status: message.data }
         }
 
-        this.callListenCallback(toJSON(message.data))
+        this.callListenCallback(!isJSON(message.data) ? message.data : toJSON(message.data))
       }
       this.ws.onclose = (event) => {
         this.setConnected(false)
         this.setSubscribed(false)
         this.setSubscribeAddresses([], false)
+        this.setSubscribeSignedData({})
         this.callCloseCallback(event)
 
         resolve(event)
@@ -503,13 +700,34 @@ export default class TCaBCIClient {
     return this.subscribedAddresses
   }
 
+  getSubscribedSignedData() {
+    return this.subscribedSignedData
+  }
+
+  /**
+   * @param {Array<string>} addresses
+   * @param {?boolean} push
+   * @return {TCaBCIClient}
+   */
   setSubscribeAddresses(addresses, push = false) {
     if (push) {
       this.subscribedAddresses.push(...addresses)
 
-      return
+      return this
     }
     this.subscribedAddresses = addresses
+
+    return this
+  }
+
+  /**
+   * @param {Object} signedData
+   * @return {TCaBCIClient}
+   */
+  setSubscribeSignedData(signedData) {
+    this.subscribedSignedData = signedData
+
+    return this
   }
 
   /**
@@ -537,6 +755,7 @@ export default class TCaBCIClient {
   /**
    * @param {Error} err
    * @param {?Object|Error} custom
+   * @throws Error
    */
   handleRestError(err, custom = null) {
     const code = err.code
@@ -549,9 +768,9 @@ export default class TCaBCIClient {
 
     switch (code) {
       case 400:
-        throw INVALID_ARGUMENTS
+        throw new Error(INVALID_ARGUMENTS)
       case 'ERR_NETWORK':
-        throw ERR_NETWORK
+        throw new Error(ERR_NETWORK)
       default:
         throw err
     }

package/client_test.js

@@ -21,7 +21,7 @@ import {
 
 describe('TCaBCIClient', () => {
   it('start with valid parameters', (done) => {
-    const client = new TCaBCIClient([], WebSocket)
+    const client = new TCaBCIClient([], WebSocket, 'transferchain', 'v1')
 
     client
       .Start()
@@ -38,7 +38,12 @@ describe('TCaBCIClient', () => {
   })
 
   it('start with valid parameters and read node addresses', (done) => {
-    const client = new TCaBCIClient([READ_NODE_ADDRESS, READ_NODE_WS_ADDRESS], WebSocket)
+    const client = new TCaBCIClient(
+      [READ_NODE_ADDRESS, READ_NODE_WS_ADDRESS],
+      WebSocket,
+      'transferchain',
+      'v1',
+    )
 
     client
       .Start()
@@ -55,7 +60,7 @@ describe('TCaBCIClient', () => {
   })
 
   it('reconnect with start and valid parameters', (done) => {
-    const client = new TCaBCIClient([], WebSocket)
+    const client = new TCaBCIClient([], WebSocket, 'transferchain', 'v1')
 
     client
       .Start()
@@ -71,13 +76,18 @@ describe('TCaBCIClient', () => {
         unitJS.assert.equal(c2, false)
         unitJS.assert.equal(b2, false)
 
-        setTimeout((client, done) => {
-          const { connected, subscribed } = client.Status()
-
-          unitJS.assert.equal(connected, true)
-          unitJS.assert.equal(subscribed, false)
-          done()
-        }, 3100, client, done)
+        setTimeout(
+          (client, done) => {
+            const { connected, subscribed } = client.Status()
+
+            unitJS.assert.equal(connected, true)
+            unitJS.assert.equal(subscribed, false)
+            done()
+          },
+          3100,
+          client,
+          done,
+        )
       })
       .catch((err) => {
         done(err)
@@ -85,7 +95,7 @@ describe('TCaBCIClient', () => {
   })
 
   it('subscribe with valid parameters', (done) => {
-    const client = new TCaBCIClient([], WebSocket)
+    const client = new TCaBCIClient([], WebSocket, 'transferchain', 'v1')
 
     client
       .Start()
@@ -110,7 +120,7 @@ describe('TCaBCIClient', () => {
   })
 
   it('should error subscribe with invalid tx type parameter', (done) => {
-    const client = new TCaBCIClient([], WebSocket)
+    const client = new TCaBCIClient([], WebSocket, 'transferchain', 'v1')
 
     client
       .Start()
@@ -129,7 +139,7 @@ describe('TCaBCIClient', () => {
   })
 
   it('unsubscribe with valid parameters', (done) => {
-    const client = new TCaBCIClient([], WebSocket)
+    const client = new TCaBCIClient([], WebSocket, 'transferchain', 'v1')
 
     client
       .Start()
@@ -158,7 +168,7 @@ describe('TCaBCIClient', () => {
   })
 
   it('last block', (done) => {
-    const client = new TCaBCIClient([], WebSocket)
+    const client = new TCaBCIClient([], WebSocket, 'transferchain', 'v1')
 
     client
       .LastBlock()
@@ -173,7 +183,7 @@ describe('TCaBCIClient', () => {
   })
 
   it('transaction search result', (done) => {
-    const client = new TCaBCIClient([], WebSocket)
+    const client = new TCaBCIClient([], WebSocket, 'transferchain', 'v1')
 
     client
       .TxSearch({
@@ -197,7 +207,7 @@ describe('TCaBCIClient', () => {
   })
   //
   it('transaction summary result', (done) => {
-    const client = new TCaBCIClient([], WebSocket)
+    const client = new TCaBCIClient([], WebSocket, 'transferchain', 'v1')
 
     client
       .TxSummary({
@@ -220,7 +230,7 @@ describe('TCaBCIClient', () => {
   })
 
   it('should error not broadcast transaction if type is incorrect', (done) => {
-    const client = new TCaBCIClient([], WebSocket)
+    const client = new TCaBCIClient([], WebSocket, 'transferchain', 'v1')
 
     try {
       client.Broadcast({
@@ -232,13 +242,13 @@ describe('TCaBCIClient', () => {
 
       done(new Error('invalid'))
     } catch (err) {
-      unitJS.assert.equal(TRANSACTION_TYPE_NOT_VALID, err)
+      unitJS.assert.equal(TRANSACTION_TYPE_NOT_VALID, err.message)
       done()
     }
   })
 
   it('should error not broadcast transaction', (done) => {
-    const client = new TCaBCIClient([], WebSocket)
+    const client = new TCaBCIClient([], WebSocket, 'transferchain', 'v1')
 
     client
       .Broadcast({
@@ -258,13 +268,13 @@ describe('TCaBCIClient', () => {
         done()
       })
       .catch((err) => {
-        unitJS.assert.equal(TRANSACTION_NOT_BROADCAST, err)
+        unitJS.assert.equal(TRANSACTION_NOT_BROADCAST, err.message)
         done()
       })
   })
 
   it('should error in bulk tx if addresses count is zero', (done) => {
-    const client = new TCaBCIClient([], WebSocket)
+    const client = new TCaBCIClient([], WebSocket, 'transferchain', 'v1')
 
     client
       .Bulk([])
@@ -286,7 +296,7 @@ describe('TCaBCIClient', () => {
       )
     }
 
-    const client = new TCaBCIClient(null, WebSocket)
+    const client = new TCaBCIClient(null, WebSocket, 'transferchain', 'v1')
 
     client
       .Bulk(addresses)

package/errors.js

@@ -1,16 +1,16 @@
-export const ALREADY_CONNECTED = new Error('Already connected'),
-  NOT_CONNECTED = new Error('Not connected'),
-  ERR_NETWORK = new Error('Network Error'),
-  INVALID_ARGUMENTS = new Error('Check your arguments'),
+export const ALREADY_CONNECTED = 'Already connected',
+  NOT_CONNECTED = 'Not connected',
+  ERR_NETWORK = 'Network Error',
+  INVALID_ARGUMENTS = 'Check your arguments',
   INVALID_ARGUMENT_WITH_CS = (val) => {
-    return new Error(INVALID_ARGUMENTS + ' ' + val)
+    return INVALID_ARGUMENTS + ' ' + val
   },
-  NOT_SUBSCRIBED = new Error('Not subscribed'),
-  ALREADY_SUBSCRIBED = new Error('Already subscribed'),
-  ADDRESSES_IS_EMPTY = new Error('Addresses is empty'),
-  BLOCK_NOT_FOUND = new Error('Block does not exist'),
-  TRANSACTION_TYPE_NOT_VALID = new Error('Transaction type is not valid'),
-  TRANSACTION_NOT_BROADCAST = new Error('Transaction can not be broadcast')
+  NOT_SUBSCRIBED = 'Not subscribed',
+  ALREADY_SUBSCRIBED = 'Already subscribed',
+  ADDRESSES_IS_EMPTY = 'Addresses is empty',
+  BLOCK_NOT_FOUND = 'Block does not exist',
+  TRANSACTION_TYPE_NOT_VALID = 'Transaction type is not valid',
+  TRANSACTION_NOT_BROADCAST = 'Transaction can not be broadcast'
 
 export class FetchError extends Error {
   code = -1

package/errors_test.js

@@ -2,7 +2,7 @@ import { FetchError } from './errors.js'
 import unitJS from 'unit.js'
 
 describe('Errors', () => {
-  it('FetchError',  () => {
+  it('FetchError', () => {
     const err = new FetchError('err1').setCode(1)
 
     unitJS.assert.equal(err.message, 'err1')

package/message.js

@@ -2,54 +2,69 @@ import { INVALID_ARGUMENTS, INVALID_ARGUMENT_WITH_CS } from './errors.js'
 import { MESSAGE_TYPE, TX_TYPE } from './constants.js'
 
 export default class Message {
-  #is_web = false
-  #type = ''
-  #addrs = []
-  #txTypes = []
-  constructor(isWeb, type, addrs, txTypes = []) {
-    this.#is_web = isWeb
-    this.#type = type
-    this.#addrs = addrs
-    this.#txTypes = txTypes
+  _is_web = false
+  _type = ''
+  _addrs = []
+  _signedData = {}
+  _txTypes = []
+
+  /**
+   * @param {boolean} isWeb
+   * @param {string} type
+   * @param {Array<string>} addrs
+   * @param {?Object} signedData
+   * @param {?Array<string>} txTypes
+   */
+  constructor(isWeb, type, addrs, signedData = null, txTypes = null) {
+    this._is_web = isWeb
+    this._type = type
+    if (addrs && Array.isArray(addrs)) this._addrs = addrs
+    if (typeof signedData === 'object') this._signedData = signedData
+    if (txTypes && Array.isArray(txTypes)) this._txTypes = txTypes
   }
 
-  ToJSONString() {
-    this.#validate()
+  ToJSON() {
+    this._validate()
 
     return JSON.stringify({
-      is_web: this.#is_web,
-      type: this.#type,
-      addrs: this.#addrs,
-      ...(this.#txTypes.length > 0 ? { tx_types: this.#txTypes } : {}),
+      is_web: this._is_web,
+      type: this._type,
+      addrs: this._addrs,
+      signed_addrs: this._signedData,
+      ...(this._txTypes.length > 0 ? { tx_types: this._txTypes } : {}),
     })
   }
 
-  #validate() {
-    if (typeof this.#is_web !== 'boolean') {
-      throw INVALID_ARGUMENT_WITH_CS('is_web')
+  _validate() {
+    if (typeof this._is_web !== 'boolean') {
+      throw new Error(INVALID_ARGUMENT_WITH_CS('is_web'))
+    }
+
+    if (typeof this._type !== 'string') {
+      throw new Error(INVALID_ARGUMENT_WITH_CS('type'))
     }
 
-    if (typeof this.#type !== 'string') {
-      throw INVALID_ARGUMENT_WITH_CS('type')
+    if (!Array.isArray(this._addrs)) {
+      throw new Error(INVALID_ARGUMENT_WITH_CS('addrs'))
     }
 
-    if (!Array.isArray(this.#addrs)) {
-      throw INVALID_ARGUMENT_WITH_CS('addrs')
+    if (typeof this._signedData !== 'object') {
+      throw new Error(INVALID_ARGUMENT_WITH_CS('signedData'))
     }
 
     if (
-      [MESSAGE_TYPE.SUBSCRIBE, MESSAGE_TYPE.UNSUBSCRIBE].indexOf(this.#type) ===
+      [MESSAGE_TYPE.SUBSCRIBE, MESSAGE_TYPE.UNSUBSCRIBE].indexOf(this._type) ===
       -1
     ) {
-      throw INVALID_ARGUMENTS
+      throw new Error(INVALID_ARGUMENTS)
     }
 
-    if (this.#txTypes.length) {
+    if (this._txTypes.length) {
       let vals = Object.values(TX_TYPE)
 
-      for (let i = 0; i < this.#txTypes.length; i++) {
-        if (vals.indexOf(this.#txTypes[i]) === -1) {
-          throw INVALID_ARGUMENT_WITH_CS('tx_types')
+      for (let i = 0; i < this._txTypes.length; i++) {
+        if (vals.indexOf(this._txTypes[i]) === -1) {
+          throw new Error(INVALID_ARGUMENT_WITH_CS('tx_types'))
         }
       }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tchain/tcabci-read-js-client",
-  "version": "2.2.4",
+  "version": "2.4.0",
   "description": "TransferChain Fastest Read Network WebSocket Client",
   "main": "client.js",
   "type": "module",

package/transaction.js

@@ -1,19 +1,19 @@
 import { INVALID_ARGUMENT_WITH_CS } from './errors.js'
 
 export default class Transaction {
-  #id
-  #block_id
-  #height
-  #identifier
-  #version
-  #typ
-  #sender_addr
-  #recipient_addr
-  #data
-  #sign
-  #fee
-  #hash
-  #inserted_at
+  _id
+  _block_id
+  _height
+  _identifier
+  _version
+  _typ
+  _sender_addr
+  _recipient_addr
+  _data
+  _sign
+  _fee
+  _hash
+  _inserted_at
 
   constructor({
     id,
@@ -30,77 +30,77 @@ export default class Transaction {
     hash,
     inserted_at,
   }) {
-    this.#id = id
-    this.#block_id = block_id
-    this.#height = height
-    this.#identifier = identifier
-    this.#version = version
-    this.#typ = typ
-    this.#sender_addr = sender_addr
-    this.#recipient_addr = recipient_addr
-    this.#data = data
-    this.#sign = sign
-    this.#fee = fee
-    this.#hash = hash
-    this.#inserted_at = inserted_at
+    this._id = id
+    this._block_id = block_id
+    this._height = height
+    this._identifier = identifier
+    this._version = version
+    this._typ = typ
+    this._sender_addr = sender_addr
+    this._recipient_addr = recipient_addr
+    this._data = data
+    this._sign = sign
+    this._fee = fee
+    this._hash = hash
+    this._inserted_at = inserted_at
   }
 
-  ToJSONString() {
-    this.#validate()
+  ToJSON() {
+    this._validate()
 
     return JSON.stringify({
-      id: this.#id,
-      block_id: this.#block_id,
-      height: this.#height,
-      identifier: this.#identifier,
-      version: this.#version,
-      typ: this.#typ,
-      sender_addr: this.#sender_addr,
-      recipient_addr: this.#recipient_addr,
-      data: this.#data,
-      sign: this.#sign,
-      fee: this.#fee,
-      hash: this.#hash,
-      inserted_at: this.#inserted_at,
+      id: this._id,
+      block_id: this._block_id,
+      height: this._height,
+      identifier: this._identifier,
+      version: this._version,
+      typ: this._typ,
+      sender_addr: this._sender_addr,
+      recipient_addr: this._recipient_addr,
+      data: this._data,
+      sign: this._sign,
+      fee: this._fee,
+      hash: this._hash,
+      inserted_at: this._inserted_at,
     })
   }
 
-  #validate() {
-    if (typeof this.#id !== 'number') {
-      throw INVALID_ARGUMENT_WITH_CS('id')
+  _validate() {
+    if (typeof this._id !== 'number') {
+      throw new Error(INVALID_ARGUMENT_WITH_CS('id'))
     }
-    if (typeof this.#block_id !== 'number') {
-      throw INVALID_ARGUMENT_WITH_CS('blockID')
+    if (typeof this._block_id !== 'number') {
+      throw new Error(INVALID_ARGUMENT_WITH_CS('blockID'))
     }
-    if (typeof this.#height !== 'number') {
-      throw INVALID_ARGUMENT_WITH_CS('height')
+    if (typeof this._height !== 'number') {
+      throw new Error(INVALID_ARGUMENT_WITH_CS('height'))
     }
-    if (typeof this.#identifier !== 'string') {
-      throw INVALID_ARGUMENT_WITH_CS('identifier')
+    if (typeof this._identifier !== 'string') {
+      throw new Error(INVALID_ARGUMENT_WITH_CS('identifier'))
     }
-    if (typeof this.#version !== 'number') {
-      throw INVALID_ARGUMENT_WITH_CS('version')
+    if (typeof this._version !== 'number') {
+      throw new Error(INVALID_ARGUMENT_WITH_CS('version'))
     }
-    if (typeof this.#typ !== 'string') {
-      throw INVALID_ARGUMENT_WITH_CS('typ')
+    if (typeof this._typ !== 'string') {
+      throw new Error(INVALID_ARGUMENT_WITH_CS('typ'))
     }
-    if (typeof this.#sender_addr !== 'string') {
-      throw INVALID_ARGUMENT_WITH_CS('senderAddr')
+    if (typeof this._sender_addr !== 'string') {
+      throw new Error(INVALID_ARGUMENT_WITH_CS('senderAddr'))
     }
-    if (typeof this.#recipient_addr !== 'string') {
-      throw INVALID_ARGUMENT_WITH_CS('recipientAddr')
+    if (typeof this._recipient_addr !== 'string') {
+      throw new Error(INVALID_ARGUMENT_WITH_CS('recipientAddr'))
     }
-    if (typeof this.#data !== 'object') {
-      throw INVALID_ARGUMENT_WITH_CS('data')
+    if (typeof this._data !== 'object') {
+      throw new Error(INVALID_ARGUMENT_WITH_CS('data'))
     }
-    if (typeof this.#sign !== 'object') {
-      throw INVALID_ARGUMENT_WITH_CS('sign')
+    if (typeof this._sign !== 'object') {
+      throw new Error(INVALID_ARGUMENT_WITH_CS('sign'))
     }
-    if (typeof this.#fee !== 'number') {
-      throw INVALID_ARGUMENT_WITH_CS('fee')
+    if (typeof this._fee !== 'number') {
+      throw new Error(INVALID_ARGUMENT_WITH_CS('fee'))
     }
-    if (typeof this.#inserted_at !== 'string') {
-      throw INVALID_ARGUMENT_WITH_CS('insertedAt')
+    if (typeof this._inserted_at !== 'string') {
+      throw new Error(INVALID_ARGUMENT_WITH_CS('insertedAt'))
     }
   }
 }

package/util.js

@@ -1,6 +1,6 @@
 import { CHARACTERS } from './constants.js'
 
-export const randomString = (length) => {
+export function randomString(length) {
   let result = ''
 
   const charactersLength = CHARACTERS.length
@@ -15,6 +15,16 @@ export const randomString = (length) => {
   return result
 }
 
-export const toJSON = (data) => {
+export function toJSON(data) {
   return JSON.parse(data)
 }
+
+export function isJSON(str) {
+  try {
+    JSON.parse(str)
+  } catch (e) {
+    return false
+  }
+
+  return true
+}