@tchain/tcabci-read-js-client 2.4.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({
@@ -248,7 +305,7 @@ describe('TCaBCIClient', () => {
   })
 
   it('should error not broadcast transaction', (done) => {
-    const client = new TCaBCIClient([], WebSocket, 'transferchain', 'v1')
+    const client = new TCaBCIClient([], WebSocket, 'medusa', 'v2')
 
     client
       .Broadcast({
@@ -274,7 +331,7 @@ describe('TCaBCIClient', () => {
   })
 
   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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tchain/tcabci-read-js-client",
-  "version": "2.4.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/websocket.js

@@ -0,0 +1,344 @@
+import { Options } from './websocketOptions.js'
+import ReconnectingWebSocket from 'reconnecting-websocket'
+
+export const MaxListenerSize = 100
+
+export class TWebSocket {
+  /**
+   * @private
+   * @type {Options}
+   */
+  _options
+
+  /**
+   * @private
+   * @type {ReconnectingWebSocket}
+   */
+  _client
+
+  _openListener = () => {}
+  _messageListener = () => {}
+  _errorListener = () => {}
+  _closeListener = () => {}
+
+  _openCallbacks = []
+  _messageCallbacks = []
+  _errorCallbacks = []
+  _closeCallbacks = []
+
+  /**
+   * @param {Options} options
+   * @constructor
+   * @throws {Error}
+   */
+  constructor(options) {
+    if (!(options instanceof Options))
+      throw new TypeError('options must be a Options')
+
+    options.check()
+    this._options = options
+  }
+
+  /**
+   * @return {boolean}
+   */
+  get ready() {
+    if (!this._client) return false
+
+    return this._client.readyState === WebSocket.OPEN
+  }
+
+  /**
+   * @return {Array<string>}
+   */
+  get openListeners() {
+    return this._openCallbacks
+  }
+
+  /**
+   * @return {Array<string>}
+   */
+  get messageListeners() {
+    return this._messageCallbacks
+  }
+
+  /**
+   * @return {Array<string>}
+   */
+  get errorListeners() {
+    return this._errorCallbacks
+  }
+
+  /**
+   * @return {Array<string>}
+   */
+  get closeListeners() {
+    return this._closeCallbacks
+  }
+
+  /**
+   * @param {?boolean} force
+   * @return {Awaited<TWebSocket>}
+   * @throws {Error}
+   */
+  async connect(force = false) {
+    if (!force && this.ready)
+      throw new Error('already connect. please use force flag')
+
+    return this._init(force)
+  }
+
+  /**
+   * @param {?number} code
+   * @return {Awaited<TWebSocket>}
+   * @throws {Error}
+   */
+  async reconnect(code = null) {
+    await this._disconnect(code)
+    this._init(true)
+
+    return this
+  }
+
+  /**
+   * @param {number} code
+   * @return {Promise<void>}
+   */
+  async disconnect(code = 1000) {
+    return this._disconnect(code)
+  }
+
+  /**
+   * @param {string|ArrayBuffer|Blob|ArrayBufferView} msg
+   */
+  send(msg) {
+    if (!this._client) return
+
+    this._client.send(msg)
+  }
+
+  /**
+   * @param {function(Event)} callback
+   * @return {TWebSocket}
+   * @throws {Error}
+   */
+  addOpenListener(callback) {
+    return this._addListener('_openCallbacks', callback)
+  }
+
+  /**
+   * @param {function(Event)} callback
+   * @return {TWebSocket}
+   */
+  removeOpenListener(callback) {
+    return this._removeListener('_openCallbacks', callback)
+  }
+
+  /**
+   * @param {function(MessageEvent)} callback
+   * @return {TWebSocket}
+   * @throws {Error}
+   */
+  addMessageListener(callback) {
+    return this._addListener('_messageCallbacks', callback)
+  }
+
+  /**
+   * @param {function(MessageEvent)} callback
+   * @return {TWebSocket}
+   */
+  removeMessageListener(callback) {
+    return this._removeListener('_messageCallbacks', callback)
+  }
+
+  /**
+   * @param {function(ErrorEvent)} callback
+   * @return {TWebSocket}
+   * @throws {Error}
+   */
+  addErrorListener(callback) {
+    return this._addListener('_errorCallbacks', callback)
+  }
+
+  /**
+   * @param {function(ErrorEvent)} callback
+   * @return {TWebSocket}
+   */
+  removeErrorListener(callback) {
+    return this._removeListener('_errorCallbacks', callback)
+  }
+
+  /**
+   * @param {function(CloseEvent)} callback
+   * @return {TWebSocket}
+   * @throws {Error}
+   */
+  addCloseListener(callback) {
+    return this._addListener('_closeCallbacks', callback)
+  }
+
+  /**
+   * @param {function(CloseEvent)} callback
+   * @return {TWebSocket}
+   */
+  removeCloseListener(callback) {
+    return this._removeListener('_closeCallbacks', callback)
+  }
+
+  /**
+   * @param {string} name
+   * @param {function(any)} callback
+   * @throws {Error}
+   * @private
+   */
+  _addListener(name, callback) {
+    if (this[name].length >= MaxListenerSize)
+      throw new Error(`listener size must be ${MaxListenerSize}`)
+
+    if (this[name].findIndex((v) => v === callback) > -1) return this
+
+    this[name].push(callback)
+
+    return this
+  }
+
+  /**
+   * @param {string} name
+   * @param {function(any)} callback
+   * @private
+   */
+  _removeListener(name, callback) {
+    const idx = this[name].findIndex((v) => v === callback)
+
+    if (idx > -1) {
+      this[name].splice(idx, 1)
+    }
+
+    return this
+  }
+
+  _callListener(name, value) {
+    if (!this[name]) return
+
+    for (const callback of this[name]) {
+      setTimeout(
+        (callback, value) => {
+          callback(value)
+        },
+        0,
+        callback,
+        value,
+      )
+    }
+  }
+
+  /**
+   * @private
+   * @param {?boolean} force
+   * @return {Awaited<TWebSocket>}
+   * @throws {Error}
+   */
+  async _init(force = false) {
+    if (!force && this.ready) return this
+
+    if (this.ready) {
+      await this.disconnect(1000)
+    }
+
+    this._make()
+
+    return this
+  }
+
+  _make() {
+    this._client = new ReconnectingWebSocket(
+      this._options.url(),
+      this._options.protocols(),
+      this._options.make(),
+    )
+
+    this._openListener = (e) => {
+      this._onOpen(e)
+    }
+    this._client.addEventListener('open', this._openListener)
+
+    this._closeListener = (e) => {
+      this._onClose(e)
+    }
+    this._client.addEventListener('close', this._closeListener)
+
+    this._messageListener = (e) => {
+      this._onMessage(e)
+    }
+    this._client.addEventListener('message', this._messageListener)
+
+    this._errorListener = (e) => {
+      this._onError(e)
+    }
+    this._client.addEventListener('error', this._errorListener)
+  }
+
+  /**
+   * @private
+   * @param {?number} code
+   * @return {Promise<void>}
+   */
+  async _disconnect(code = 1000) {
+    if (!this.ready) return
+
+    this._close(code)
+  }
+
+  _close(code = 1000) {
+    if (!code) code = 1000
+
+    this._client.removeEventListener('open', this._openListener)
+    this._client.removeEventListener('close', this._closeListener)
+    this._client.removeEventListener('message', this._messageListener)
+    this._client.removeEventListener('error', this._errorListener)
+
+    this._openCallbacks.length = 0
+    this._errorCallbacks.length = 0
+    this._closeCallbacks.length = 0
+    this._messageCallbacks.length = 0
+
+    this._openListener = () => {}
+    this._closeListener = () => {}
+    this._closeListener = () => {}
+    this._messageListener = () => {}
+
+    this._client.close(code)
+  }
+
+  /**
+   * @param {CloseEvent} event
+   * @private
+   */
+  _onClose(event) {
+    this._callListener('_closeCallbacks', event)
+  }
+
+  /**
+   * @param {ErrorEvent} event
+   * @private
+   */
+  _onError(event) {
+    this._callListener('_errorCallbacks', event)
+  }
+
+  /**
+   * @param {MessageEvent} msg
+   * @private
+   */
+  _onMessage(msg) {
+    this._callListener('_messageCallbacks', msg)
+  }
+
+  /**
+   * @param {Event} event
+   * @private
+   */
+  _onOpen(event) {
+    this._callListener('_openCallbacks', event)
+  }
+}