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

package/README.md

@@ -6,8 +6,7 @@ Read Node WebSocket Address: [wss://read-node-01.transferchain.io/ws](wss://read
 
 ## Networks
 
-- transferchain - v1
-- medusa - v2 (new blocks)
+- medusa - v2
 
 ## Installation
 

package/client.js

@@ -1,4 +1,3 @@
-import ReconnectingWebSocket from 'reconnecting-websocket'
 import {
   ADDRESSES_IS_EMPTY,
   ALREADY_CONNECTED,
@@ -18,7 +17,9 @@ import {
   TX_TYPE,
 } from './constants.js'
 import Message from './message.js'
-import { toJSON } from './util.js'
+import { isJSON, toJSON } from './util.js'
+import { DefaultTimeout, Options } from './websocketOptions.js'
+import { TWebSocket } from './websocket.js'
 
 /**
  * @callback successCallback
@@ -41,32 +42,36 @@ import { toJSON } from './util.js'
  * @return void
  */
 export default class TCaBCIClient {
-  subscribed = false
-  subscribedAddresses = []
-  connected = false
-  chainName = 'transferchain'
-  chainVersion = 'v1'
-  version = 'v2.3.0'
+  _subscribed = false
+  _subscribedAddresses = []
+  _subscribedSignedData = {}
+  _connected = false
+  _chainName = 'transferchain'
+  _chainVersion = 'v1'
+  _version = 'v2.3.0'
   /**
    * @type {?successCallback}
    */
-  successCb = null
+  _successCb = null
   /**
    * @type {?errorCallback}
    */
-  errorCb = null
+  _errorCb = null
   /**
    * @type {?closeCallback}
    */
-  closeCb = null
+  _closeCb = null
   /**
    * @type {?listenCallback}
    */
-  listenCb = null
-  wsLibrary = null
-  ws = null
-  readNodeAddress = READ_NODE_ADDRESS
-  readNodeWSAddress = READ_NODE_WS_ADDRESS
+  _listenCb = null
+  _wsLibrary = null
+  /**
+   * @type {TWebSocket}
+   */
+  _ws
+  _readNodeAddress = READ_NODE_ADDRESS
+  _readNodeWSAddress = READ_NODE_WS_ADDRESS
 
   /**
    * @param {Array<String>} readNodeAddresses
@@ -80,19 +85,21 @@ export default class TCaBCIClient {
     chainName = null,
     chainVersion = null,
   ) {
-    if (!wsLibrary) throw INVALID_ARGUMENTS
-    this.wsLibrary = wsLibrary
+    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]
+      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
+    if (chainName) this._chainName = chainName
+    if (chainVersion) this._chainVersion = chainVersion
   }
 
   /**
@@ -103,7 +110,7 @@ export default class TCaBCIClient {
   httpClient(uri, req) {
     req.cache = 'no-cache'
     req.headers = {
-      Client: `tcabaci-read-js-client${this.version}`,
+      Client: `tcabaci-read-js-client${this._version}`,
     }
 
     if (typeof AbortSignal !== 'undefined') {
@@ -112,13 +119,13 @@ export default class TCaBCIClient {
 
     req.priority = 'high'
 
-    return fetch(this.readNodeAddress + uri, req).then((response) =>
+    return fetch(this._readNodeAddress + uri, req).then((response) =>
       this.handleRestResponse(response),
     )
   }
 
   Socket() {
-    return this.ws
+    return this._ws
   }
 
   /**
@@ -126,7 +133,7 @@ export default class TCaBCIClient {
    * @constructor
    */
   SetSuccessCallback(cb) {
-    this.successCb = cb
+    this._successCb = cb
 
     return this
   }
@@ -136,7 +143,7 @@ export default class TCaBCIClient {
    * @constructor
    */
   SetErrorCallback(cb) {
-    this.errorCb = cb
+    this._errorCb = cb
 
     return this
   }
@@ -146,7 +153,7 @@ export default class TCaBCIClient {
    * @constructor
    */
   SetCloseCallback(cb) {
-    this.closeCb = cb
+    this._closeCb = cb
 
     return this
   }
@@ -156,7 +163,7 @@ export default class TCaBCIClient {
    * @constructor
    */
   SetListenCallback(cb) {
-    this.listenCb = cb
+    this._listenCb = cb
 
     return this
   }
@@ -165,41 +172,58 @@ export default class TCaBCIClient {
     return this.connect()
   }
 
-  Stop() {
+  /**
+   * @return {Awaited<TCaBCIClient>}
+   * @throws {Error}
+   */
+  async Stop() {
     if (!this.getConnected()) {
-      throw NOT_CONNECTED
+      throw new Error(NOT_CONNECTED)
     }
-    this.Disconnect(1000)
+    await this.Disconnect(1000)
     this.setConnected(false)
     this.setSubscribed(false)
 
     return this
   }
 
-  Subscribe(addresses = [], txTypes = []) {
+  /**
+   * @param {Array<string>} addresses
+   * @param {Object} signedData
+   * @param {?Array<string>} txTypes
+   * @return {TCaBCIClient}
+   * @throws {Error}
+   */
+  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 = []
@@ -212,26 +236,40 @@ export default class TCaBCIClient {
       addrs = newAddress
     }
 
-    const message = new Message(true, MESSAGE_TYPE.SUBSCRIBE, addrs, txTypes)
+    if (this.getSubscribedSignedData().length > 0) {
+      sdata = this.getSubscribedSignedData()
+    }
 
-    this.ws.send(message.ToJSONString())
+    const message = new Message(
+      true,
+      MESSAGE_TYPE.SUBSCRIBE,
+      addrs,
+      sdata,
+      txTypes,
+    )
+
+    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(
+    this._ws.send(
       new Message(
         true,
         MESSAGE_TYPE.UNSUBSCRIBE,
         this.getSubscribeAddresses(),
-      ).ToJSONString(),
+      ).ToJSON(),
     )
     this.setSubscribed(false)
     this.setSubscribeAddresses([])
+    this.setSubscribeSignedData({})
   }
 
   /**
@@ -241,7 +279,7 @@ export default class TCaBCIClient {
    */
   LastBlock(chainName = null, chainVersion = null) {
     return this.httpClient(
-      `/v1/blocks?chain_name=${chainName ?? this.chainName}&chain_version=${chainVersion ?? this.chainVersion}&limit=1&offset=0`,
+      `/v1/blocks?chain_name=${chainName ?? this._chainName}&chain_version=${chainVersion ?? this._chainVersion}&limit=1&offset=0`,
       {
         method: 'GET',
       },
@@ -249,15 +287,23 @@ export default class TCaBCIClient {
       .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 }
       })
@@ -267,6 +313,7 @@ export default class TCaBCIClient {
   /**
    * @param {?Array<string>} recipientAddrs
    * @param {?Array<string>} senderAddrs
+   * @param {?Object} signedData
    * @param {?string} typ
    * @param {?Array<string>} types
    * @param {?string} chainName
@@ -276,22 +323,24 @@ export default class TCaBCIClient {
   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,
+        chain_name: chainName ?? this._chainName,
+        chain_version: chainVersion ?? this._chainVersion,
         recipient_addrs: recipientAddrs,
         sender_addrs: senderAddrs,
+        signed_addrs: signedData,
         ...(types ? { types: types } : { typ: typ }),
       }),
     })
@@ -316,6 +365,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
@@ -334,6 +384,7 @@ export default class TCaBCIClient {
     lastOrder,
     recipientAddrs,
     senderAddrs,
+    signedData,
     hashes,
     typ,
     types,
@@ -347,13 +398,14 @@ export default class TCaBCIClient {
     return this.httpClient('/v1/tx_search/p', {
       method: 'POST',
       body: JSON.stringify({
-        chain_name: chainName ?? this.chainName,
-        chain_version: chainVersion ?? this.chainVersion,
+        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 } : {}),
@@ -373,10 +425,10 @@ export default class TCaBCIClient {
 
   Status() {
     return {
-      chain_name: this.chainName,
-      chain_version: this.chainVersion,
-      connected: this.connected,
-      subscribed: this.subscribed,
+      chain_name: this._chainName,
+      chain_version: this._chainVersion,
+      connected: this._connected,
+      subscribed: this._subscribed,
     }
   }
 
@@ -497,7 +549,7 @@ export default class TCaBCIClient {
     commit = false,
   ) {
     if (Object.values(TX_TYPE).indexOf(type) < 0) {
-      throw TRANSACTION_TYPE_NOT_VALID
+      throw new Error(TRANSACTION_TYPE_NOT_VALID)
     }
 
     return this.httpClient(
@@ -519,11 +571,14 @@ export default class TCaBCIClient {
       .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
@@ -532,6 +587,7 @@ export default class TCaBCIClient {
    */
   Bulk(
     addresses = [],
+    signedData = {},
     maxHeight = null,
     chainName = null,
     chainVersion = null,
@@ -539,120 +595,144 @@ export default class TCaBCIClient {
     return this.httpClient('/v1/bulk_tx', {
       method: 'POST',
       body: JSON.stringify({
-        chain_name: chainName ?? this.chainName,
-        chain_version: chainVersion ?? this.chainVersion,
+        chain_name: chainName ?? this._chainName,
+        chain_version: chainVersion ?? this._chainVersion,
         addresses: addresses,
+        signed_addrs: signedData,
         ...(maxHeight ? { max_height: maxHeight } : {}),
       }),
     })
   }
 
-  Disconnect(code = 1000) {
+  async Disconnect(code = 1000) {
     if (this.getConnected()) {
-      this.ws.close(code)
+      await this._ws.disconnect(code)
+
+      this.setConnected(false)
+      this.setSubscribed(false)
     }
   }
 
-  Reconnect(code = 1000) {
+  async Reconnect(code = 1000) {
     if (this.getConnected()) {
-      this.ws.reconnect(code)
+      await this.Disconnect(code)
     }
 
+    await this.connect()
+
     return this
   }
 
   callSuccessCallback(event) {
-    if (this.successCb) this.successCb(event)
+    if (this._successCb) this._successCb(event)
   }
 
   callErrorCallback(event) {
-    if (this.errorCb) this.errorCb(event)
+    if (this._errorCb) this._errorCb(event)
   }
 
   callCloseCallback(event) {
-    if (this.closeCb) this.closeCb(event)
+    if (this._closeCb) this._closeCb(event)
   }
 
   callListenCallback(message) {
-    if (this.listenCb) this.listenCb(message)
+    if (this._listenCb) this._listenCb(message)
   }
 
   /**
-   * @return {Promise<Event>}
+   * @return {Promise<TWebSocket>}
    */
   async connect() {
     if (this.getConnected()) {
-      return Promise.reject(ALREADY_CONNECTED)
+      return Promise.reject(new Error(ALREADY_CONNECTED))
     }
 
-    const options = {
-      WebSocket: this.wsLibrary,
-      connectionTimeout: 1000,
-      maxRetries: 10,
-    }
+    const options = new Options(this._readNodeWSAddress)
+    options.setCustomWS(this._wsLibrary)
 
-    this.ws = new ReconnectingWebSocket(this.readNodeWSAddress, [], options)
+    this._ws = new TWebSocket(options)
 
-    return new Promise((resolve, reject) => {
-      this.ws.onerror = (event) => {
-        this.setConnected(false)
-        this.setSubscribed(false)
-        this.setSubscribeAddresses([], false)
-        this.callErrorCallback(event)
+    this._ws.addErrorListener((e) => {
+      this.setConnected(false)
+      this.setSubscribed(false)
+      this.setSubscribeAddresses([], false)
+      this.setSubscribeSignedData({})
+      this.callErrorCallback(e)
+    })
 
-        reject(event)
-      }
-      this.ws.onopen = (event) => {
-        this.setConnected(true)
-        this.callSuccessCallback(event)
+    this._ws.addOpenListener((e) => {
+      this.setConnected(true)
+      this.callSuccessCallback(e)
+    })
 
-        resolve(event)
+    this._ws.addMessageListener((message) => {
+      if (message.data === 'OK' && message.data.length < 10) {
+        return { status: message.data }
       }
-      this.ws.onmessage = (message) => {
-        if (message.data === 'OK' && message.data.length < 10) {
-          return { status: message.data }
-        }
 
-        this.callListenCallback(toJSON(message.data))
-      }
-      this.ws.onclose = (event) => {
-        this.setConnected(false)
-        this.setSubscribed(false)
-        this.setSubscribeAddresses([], false)
-        this.callCloseCallback(event)
+      this.callListenCallback(!isJSON(message.data) ? message.data : toJSON(message.data))
+    })
 
-        resolve(event)
-      }
+    this._ws.addCloseListener((e) => {
+      console.log('came gggg ', e)
+      this.setConnected(false)
+      this.setSubscribed(false)
+      this.setSubscribeAddresses([], false)
+      this.setSubscribeSignedData({})
+      this.callCloseCallback(e)
     })
+
+    return this._ws.connect()
   }
 
   getConnected() {
-    return this.connected
+    return this._connected
   }
 
   setConnected(value) {
-    this.connected = value
+    this._connected = value
   }
 
   getSubscribed() {
-    return this.subscribed
+    return this._subscribed
   }
 
   setSubscribed(value) {
-    this.subscribed = value
+    this._subscribed = value
   }
 
   getSubscribeAddresses() {
-    return this.subscribedAddresses
+    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)
+      this._subscribedAddresses.push(...addresses)
 
-      return
+      return this
     }
-    this.subscribedAddresses = addresses
+    this._subscribedAddresses = addresses
+
+    return this
+  }
+
+  /**
+   * @param {Object} signedData
+   * @return {TCaBCIClient}
+   */
+  setSubscribeSignedData(signedData) {
+    this._subscribedSignedData = signedData
+
+    return this
   }
 
   /**
@@ -680,6 +760,7 @@ export default class TCaBCIClient {
   /**
    * @param {Error} err
    * @param {?Object|Error} custom
+   * @throws Error
    */
   handleRestError(err, custom = null) {
     const code = err.code
@@ -692,9 +773,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
     }