@tchain/tcabci-read-js-client 2.3.0 → 2.5.0

package/client_test.js

@@ -10,26 +10,30 @@ import {
   READ_NODE_WS_ADDRESS,
   TX_TYPE,
 } from './constants.js'
-//
-// const {
-//   TX_TYPE,
-//   READ_NODE_ADDRESS,
-//   READ_NODE_WS_ADDRESS,
-// } = require('./constants')
-//
-// const { randomString } = require('./util')
+
+const waiter = async (timeout = 1000) => {
+  return new Promise((resolve) => setTimeout(resolve, timeout))
+}
 
 describe('TCaBCIClient', () => {
   it('start with valid parameters', (done) => {
-    const client = new TCaBCIClient([], WebSocket, 'transferchain', 'v1')
+    const client = new TCaBCIClient([], WebSocket, 'medusa', 'v2')
 
     client
       .Start()
+      .then(() => {
+        return waiter(500)
+      })
       .then(() => {
         const { connected, subscribed } = client.Status()
 
         unitJS.assert.equal(connected, true)
         unitJS.assert.equal(subscribed, false)
+      })
+      .then(() => {
+        return client.Disconnect()
+      })
+      .then(() => {
         done()
       })
       .catch((err) => {
@@ -41,17 +45,25 @@ describe('TCaBCIClient', () => {
     const client = new TCaBCIClient(
       [READ_NODE_ADDRESS, READ_NODE_WS_ADDRESS],
       WebSocket,
-      'transferchain',
-      'v1',
+      'medusa',
+      'v2',
     )
 
     client
       .Start()
+      .then(() => {
+        return waiter(500)
+      })
       .then(() => {
         const { connected, subscribed } = client.Status()
 
         unitJS.assert.equal(connected, true)
         unitJS.assert.equal(subscribed, false)
+      })
+      .then(() => {
+        return client.Disconnect()
+      })
+      .then(() => {
         done()
       })
       .catch((err) => {
@@ -60,34 +72,49 @@ describe('TCaBCIClient', () => {
   })
 
   it('reconnect with start and valid parameters', (done) => {
-    const client = new TCaBCIClient([], WebSocket, 'transferchain', 'v1')
+    const client = new TCaBCIClient([], WebSocket, 'medusa', 'v2')
 
     client
       .Start()
+      .then(() => {
+        return waiter(500)
+      })
       .then(() => {
         const { connected, subscribed } = client.Status()
 
         unitJS.assert.equal(connected, true)
         unitJS.assert.equal(subscribed, false)
 
-        client.Reconnect(1003)
+        return client.Reconnect(1007)
+      })
+      .then(() => {
         const { connected: c2, subscribed: b2 } = client.Status()
-
         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,
-        )
+        return waiter(500)
+      })
+      .then(() => {
+        return new Promise((resolve) => {
+          setTimeout(
+            (client, res) => {
+              const { connected, subscribed } = client.Status()
+
+              unitJS.assert.equal(connected, true)
+              unitJS.assert.equal(subscribed, false)
+              res()
+            },
+            3100,
+            client,
+            resolve,
+          )
+        })
+      })
+      .then(() => {
+        return client.Disconnect()
+      })
+      .then(() => {
+        done()
       })
       .catch((err) => {
         done(err)
@@ -95,16 +122,22 @@ describe('TCaBCIClient', () => {
   })
 
   it('subscribe with valid parameters', (done) => {
-    const client = new TCaBCIClient([], WebSocket, 'transferchain', 'v1')
+    const client = new TCaBCIClient([], WebSocket, 'medusa', 'v2')
 
     client
       .Start()
+      .then(() => {
+        return waiter(750)
+      })
       .then(() => {
         client.Subscribe(
           [
             '2mSCzresfg8Gwu7LZ9k9BTWkQAcQEkvYHFUSCZE2ubM4QV89PTeSYwQDqBas3ykq2emHEK6VRvxdgoe1vrhBbQGN',
           ],
-          [TX_TYPE.TX_TYPE_STORAGE],
+          {
+            '2mSCzresfg8Gwu7LZ9k9BTWkQAcQEkvYHFUSCZE2ubM4QV89PTeSYwQDqBas3ykq2emHEK6VRvxdgoe1vrhBbQGN':
+              '2mSCzresfg8Gwu7LZ9k9BTWkQAcQEkvYHFUSCZE2ubM4QV89PTeSYwQDqBas3ykq2emHEK6VRvxdgoe1vrhBbQGN',
+          },
         )
 
         const { connected, subscribed } = client.Status()
@@ -112,6 +145,9 @@ describe('TCaBCIClient', () => {
         unitJS.assert.equal(connected, true)
         unitJS.assert.equal(subscribed, true)
 
+        return client.Disconnect()
+      })
+      .then(() => {
         done()
       })
       .catch((err) => {
@@ -120,17 +156,25 @@ describe('TCaBCIClient', () => {
   })
 
   it('should error subscribe with invalid tx type parameter', (done) => {
-    const client = new TCaBCIClient([], WebSocket, 'transferchain', 'v1')
+    const client = new TCaBCIClient([], WebSocket, 'medusa', 'v2')
 
     client
       .Start()
+      .then(() => {
+        return waiter(500)
+      })
       .then(() => {
         client.Subscribe(
           [
             '2mSCzresfg8Gwu7LZ9k9BTWkQAcQEkvYHFUSCZE2ubM4QV89PTeSYwQDqBas3ykq2emHEK6VRvxdgoe1vrhBbQGN',
+            '2mSCzresfg8Gwu7LZ9k9BTWkQAcQEkvYHFUSCZE2ubM4QV89PTeSYwQDqBas3ykq2emHEK6VRvxdgoe1vrhBbQGU',
           ],
           ['invalid'],
         )
+
+        return client.Disconnect()
+      })
+      .then(() => {
         done(new Error('invalid'))
       })
       .catch(() => {
@@ -139,14 +183,23 @@ describe('TCaBCIClient', () => {
   })
 
   it('unsubscribe with valid parameters', (done) => {
-    const client = new TCaBCIClient([], WebSocket, 'transferchain', 'v1')
+    const client = new TCaBCIClient([], WebSocket, 'medusa', 'v2')
 
     client
       .Start()
       .then(() => {
-        client.Subscribe([
-          '2mSCzresfg8Gwu7LZ9k9BTWkQAcQEkvYHFUSCZE2ubM4QV89PTeSYwQDqBas3ykq2emHEK6VRvxdgoe1vrhBbQGN',
-        ])
+        return waiter(500)
+      })
+      .then(() => {
+        client.Subscribe(
+          [
+            '2mSCzresfg8Gwu7LZ9k9BTWkQAcQEkvYHFUSCZE2ubM4QV89PTeSYwQDqBas3ykq2emHEK6VRvxdgoe1vrhBbQGN',
+          ],
+          {
+            '2mSCzresfg8Gwu7LZ9k9BTWkQAcQEkvYHFUSCZE2ubM4QV89PTeSYwQDqBas3ykq2emHEK6VRvxdgoe1vrhBbQGN':
+              '2mSCzresfg8Gwu7LZ9k9BTWkQAcQEkvYHFUSCZE2ubM4QV89PTeSYwQDqBas3ykq2emHEK6VRvxdgoe1vrhBbQGN',
+          },
+        )
         const { connected, subscribed } = client.Status()
 
         unitJS.assert.equal(connected, true)
@@ -160,6 +213,10 @@ describe('TCaBCIClient', () => {
 
         unitJS.assert.equal(connected, true)
         unitJS.assert.equal(subscribed, false)
+
+        return client.Disconnect()
+      })
+      .then(() => {
         done()
       })
       .catch((err) => {
@@ -168,7 +225,7 @@ describe('TCaBCIClient', () => {
   })
 
   it('last block', (done) => {
-    const client = new TCaBCIClient([], WebSocket, 'transferchain', 'v1')
+    const client = new TCaBCIClient([], WebSocket, 'medusa', 'v2')
 
     client
       .LastBlock()
@@ -183,7 +240,7 @@ describe('TCaBCIClient', () => {
   })
 
   it('transaction search result', (done) => {
-    const client = new TCaBCIClient([], WebSocket, 'transferchain', 'v1')
+    const client = new TCaBCIClient([], WebSocket, 'medusa', 'v2')
 
     client
       .TxSearch({
@@ -207,7 +264,7 @@ describe('TCaBCIClient', () => {
   })
   //
   it('transaction summary result', (done) => {
-    const client = new TCaBCIClient([], WebSocket, 'transferchain', 'v1')
+    const client = new TCaBCIClient([], WebSocket, 'medusa', 'v2')
 
     client
       .TxSummary({
@@ -230,7 +287,7 @@ describe('TCaBCIClient', () => {
   })
 
   it('should error not broadcast transaction if type is incorrect', (done) => {
-    const client = new TCaBCIClient([], WebSocket, 'transferchain', 'v1')
+    const client = new TCaBCIClient([], WebSocket, 'medusa', 'v2')
 
     try {
       client.Broadcast({
@@ -242,13 +299,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, 'transferchain', 'v1')
+    const client = new TCaBCIClient([], WebSocket, 'medusa', 'v2')
 
     client
       .Broadcast({
@@ -268,13 +325,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, 'transferchain', 'v1')
+    const client = new TCaBCIClient([], WebSocket, 'medusa', 'v2')
 
     client
       .Bulk([])
@@ -296,7 +353,7 @@ describe('TCaBCIClient', () => {
       )
     }
 
-    const client = new TCaBCIClient(null, WebSocket, 'transferchain', 'v1')
+    const client = new TCaBCIClient(null, WebSocket, 'medusa', 'v2')
 
     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/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.3.0",
+  "version": "2.5.0",
   "description": "TransferChain Fastest Read Network WebSocket Client",
   "main": "client.js",
   "type": "module",
@@ -23,17 +23,18 @@
   },
   "homepage": "https://github.com/TransferChain/tcabci-read-js-client#readme",
   "devDependencies": {
+    "chai": "^5.2.1",
     "eslint": "^9.15.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-import": "^2.31.0",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-promise": "^7.1.0",
-    "express": "^4.21.1",
-    "mocha": "^10.8.2",
+    "express": "^5.1.0",
+    "mocha": "^11.7.1",
     "nyc": "^17.1.0",
-    "prettier": "^3.3.3",
+    "prettier": "^3.6.2",
     "unit.js": "^2.1.1",
-    "ws": "^8.18.0"
+    "ws": "^8.18.3"
   },
   "dependencies": {
     "reconnecting-websocket": "^4.4.0"

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
+}