@tchain/tcabci-read-js-client 2.6.6 → 2.7.1

package/block.d.ts

@@ -0,0 +1,13 @@
+import { Transaction } from './transaction'
+
+export declare class Block {
+  get Height(): number
+  get TXS(): number
+  get Hash(): string|null
+  get Transactions(): Transaction[]
+  get ChainName(): string
+  get ChainVersion(): string
+
+  static FromJSON(value: string): { block?: Block, error?: Error }
+  static FromObject(obj: Record<string, any>): { block?: Block, error?: Error }
+}

package/block.js

@@ -0,0 +1,110 @@
+import { Transaction } from './transaction.js'
+
+export class Block {
+  _height
+  _txs
+  _hash
+  _transactions
+  _chainName
+  _chainVersion
+
+  get Height() {
+    return this._height
+  }
+
+  get TXS() {
+    return this._txs
+  }
+
+  get Hash() {
+    return this._hash
+  }
+
+  get Transactions() {
+    return this._transactions
+  }
+
+  get ChainName() {
+    return this._chainName
+  }
+
+  get ChainVersion() {
+    return this._chainVersion
+  }
+
+  /**
+   * @param {string} value
+   * @return {{block: ?Block, error: ?Error}}
+   * @constructor
+   */
+  static FromJSON(value) {
+    try {
+      const bl = new Block(),
+        parsed = JSON.parse(value)
+
+      bl._transactions = []
+
+      if (typeof parsed.height !== 'undefined') bl._height = parsed.height
+      if (typeof parsed.txs !== 'undefined') bl._txs = parsed.txs
+      if (typeof parsed.hash !== 'undefined') bl._hash = parsed.hash
+      if (typeof parsed.chain_name !== 'undefined')
+        bl._chainName = parsed.chain_name
+      if (typeof parsed.chain_version !== 'undefined')
+        bl._chainVersion = parsed.chain_version
+
+      if (typeof parsed.transactions !== 'undefined') {
+        for (let i = 0; i < parsed.transactions.length; i++) {
+          const { transaction, error } = Transaction.FromObject(
+            parsed.transactions[i],
+          )
+          if (error) {
+            return { block: null, error: error }
+          }
+
+          bl._transactions.push(transaction)
+        }
+      }
+
+      return { block: bl, error: null }
+    } catch (e) {
+      return { block: null, error: e }
+    }
+  }
+
+  /**
+   * @param {object} obj
+   * @return {{block: ?Block, error: ?Error}}
+   * @constructor
+   */
+  static FromObject(obj) {
+    try {
+      const bl = new Block()
+
+      bl._transactions = []
+
+      if (typeof obj.height !== 'undefined') bl._height = obj.height
+      if (typeof obj.txs !== 'undefined') bl._txs = obj.txs
+      if (typeof obj.hash !== 'undefined') bl._hash = obj.hash
+      if (typeof obj.chain_name !== 'undefined') bl._chainName = obj.chain_name
+      if (typeof obj.chain_version !== 'undefined')
+        bl._chainVersion = obj.chain_version
+
+      if (typeof obj.transactions !== 'undefined') {
+        for (let i = 0; i < obj.transactions.length; i++) {
+          const { transaction, error } = Transaction.FromObject(
+            obj.transactions[i],
+          )
+          if (error) {
+            return { block: null, error: error }
+          }
+
+          bl._transactions.push(transaction)
+        }
+      }
+
+      return { block: bl, error: null }
+    } catch (e) {
+      return { block: null, error: e }
+    }
+  }
+}

package/breaker.d.ts

@@ -0,0 +1,3 @@
+export declare class Breaker {
+  execute(fn: () => Promise<any>): Promise<any>
+}

package/breaker.js

@@ -0,0 +1,50 @@
+import {
+  ConsecutiveBreaker,
+  ExponentialBackoff,
+  retry,
+  handleType,
+  circuitBreaker,
+  wrap,
+} from 'cockatiel'
+import { FetchError } from './errors.js'
+
+export class Breaker {
+  _options = {
+    halfOpenAfter: 10 * 1000,
+    breaker: new ConsecutiveBreaker(10),
+  }
+  _retryPolicy = retry(
+    handleType(FetchError, (err) =>
+      [502, 503, 504].includes(err.status),
+    ).orType(Error, (err) => {
+      return err.message.toLowerCase().search('failed to fetch') > -1
+    }),
+    {
+      maxAttempts: 10,
+      backoff: new ExponentialBackoff({
+        initialDelay: 500,
+        maxDelay: 15000,
+      }),
+    },
+  )
+  _circuitBreakerPolicy = circuitBreaker(
+    handleType(FetchError, (err) =>
+      [502, 503, 504].includes(err.status),
+    ).orType(Error, (err) => {
+      return err.message.toLowerCase().search('failed to fetch') > -1
+    }),
+    this._options,
+  )
+  _retryWithBreaker = wrap(this._retryPolicy, this._circuitBreakerPolicy)
+  constructor() {}
+
+  /**
+   * @param {function} fn
+   * @return {Promise<*>}
+   */
+  execute(fn) {
+    return this._retryWithBreaker.execute(fn).catch((err) => {
+      return Promise.reject(err)
+    })
+  }
+}

package/callback.d.ts

@@ -1,6 +1,11 @@
 import { Transaction } from './transaction'
+import { Block } from './block'
 
 export declare type SuccessCallback = (event: Event) => void
 export declare type ErrorCallback = (event: Event) => void
 export declare type CloseCallback = (event: Event) => void
-export declare type ListenCallback = (tx: Transaction) => void
+export declare type ListenCallback = (
+  block: Block | null,
+  tx: Transaction | null,
+  msg: any | null,
+) => void

package/client.js

@@ -1,8 +1,6 @@
 import {
-  FetchError,
   ALREADY_CONNECTED,
   BLOCK_NOT_FOUND,
-  ERR_NETWORK,
   INVALID_ARGUMENT_WITH_CS,
   INVALID_ARGUMENTS,
   NOT_CONNECTED,
@@ -11,10 +9,19 @@ import {
   TRANSACTION_TYPE_NOT_VALID,
 } from './errors.js'
 import { READ_NODE_ADDRESS, READ_NODE_WS_ADDRESS } from './constants.js'
-import Message, { SUBSCRIBEMessage, UNSUBSCRIBEMessage } from './message.js'
+import Message, {
+  Block as MBlock,
+  Transaction as MTransaction,
+  SUBSCRIBEMessage,
+  UNSUBSCRIBEMessage,
+  Subscription,
+  OK,
+} from './message.js'
 import { Options } from './websocketOptions.js'
 import { TWebSocket } from './websocket.js'
 import { Transaction, TX_TYPE_LIST } from './transaction.js'
+import { Block } from './block.js'
+import { HTTP } from './http.js'
 
 /**
  * @callback SuccessCallback
@@ -36,18 +43,21 @@ import { Transaction, TX_TYPE_LIST } from './transaction.js'
 
 /**
  * @callback ListenCallback
- * @param {*} message
+ * @param {?Block} block
+ * @param {?Transaction} transaction
+ * @param {?*} msg
  * @return void
  */
 
 export default class TCaBCIClient {
+  _httpClient = new HTTP()
   _subscribed = false
   _subscribedAddresses = []
   _SubscribedSignedData = {}
   _connected = false
   _chainName = 'transferchain'
   _chainVersion = 'v1'
-  _version = `v2.6.6`
+  _version = `v2.7.1`
   /**
    * @type {?SuccessCallback}
    */
@@ -100,6 +110,7 @@ export default class TCaBCIClient {
 
       this._readNodeAddress = readNodeAddresses[0]
       this._readNodeWSAddress = readNodeAddresses[1]
+      this._httpClient.setBaseURL(readNodeAddresses[0])
     }
 
     this._options = new Options(this._readNodeWSAddress)
@@ -258,18 +269,16 @@ export default class TCaBCIClient {
       addrs.push(...newAddress)
     }
 
-    const message = new Message(
-      true,
-      SUBSCRIBEMessage,
-      addrs,
-      _signedData,
-      txTypes,
+    this._ws.send(
+      new Message({
+        isWeb: true,
+        type: SUBSCRIBEMessage,
+        addrs: addrs,
+        signedData: _signedData,
+        txTypes,
+      }).ToJSON(),
     )
-
-    this._ws.send(message.ToJSON())
-    this._setSubscribeAddresses(addrs, true)
-      ._setSubscribeSignedData(signedData)
-      ._setSubscribed(true)
+    this._setSubscribeAddresses(addrs, true)._setSubscribeSignedData(signedData)
 
     return this
   }
@@ -282,7 +291,11 @@ export default class TCaBCIClient {
       throw new Error(NOT_SUBSCRIBED)
     }
     this._ws.send(
-      new Message(true, UNSUBSCRIBEMessage, this.SubscribeAddresses).ToJSON(),
+      new Message({
+        isWeb: true,
+        type: UNSUBSCRIBEMessage,
+        addrs: this.SubscribeAddresses,
+      }).ToJSON(),
     )
     this._setSubscribed(false)
     this._setSubscribeAddresses([])
@@ -297,12 +310,13 @@ export default class TCaBCIClient {
    * @return {Promise<{blocks: Transaction[], total_count: number}>}
    */
   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',
-      },
-    )
+    return this._httpClient
+      .request(
+        `/v1/blocks?chain_name=${chainName ?? this._chainName}&chain_version=${chainVersion ?? this._chainVersion}&limit=1&offset=0`,
+        {
+          method: 'GET',
+        },
+      )
       .then((res) => {
         const data = []
 
@@ -314,7 +328,7 @@ export default class TCaBCIClient {
 
         return { blocks: data, total_count: res.total_count }
       })
-      .catch((e) => this._handleRestError(e, new Error(BLOCK_NOT_FOUND)))
+      .catch((e) => this._httpClient.handleError(e, new Error(BLOCK_NOT_FOUND)))
   }
 
   /**
@@ -327,17 +341,18 @@ export default class TCaBCIClient {
       return Promise.reject(new Error(INVALID_ARGUMENTS))
     }
 
-    return this._httpClient(`/v1/tx/${id}`, {
-      method: 'GET',
-      headers: { 'X-Signature': signature },
-    })
+    return this._httpClient
+      .request(`/v1/tx/${id}`, {
+        method: 'GET',
+        headers: { 'X-Signature': signature },
+      })
       .then((res) => {
         const { transaction, error } = Transaction.FromObject(res.data)
         if (error) return Promise.reject(error)
 
         return { tx: transaction }
       })
-      .catch((e) => this._handleRestError(e))
+      .catch((e) => this._httpClient.handleError(e))
   }
 
   /**
@@ -371,17 +386,18 @@ export default class TCaBCIClient {
       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 }),
-      }),
-    })
+    return this._httpClient
+      .request('/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) => {
         let firstTransaction, lastTransaction
 
@@ -411,7 +427,7 @@ export default class TCaBCIClient {
           total_count: res.total_count,
         }
       })
-      .catch((e) => this._handleRestError(e))
+      .catch((e) => this._httpClient.handleError(e))
   }
 
   /**
@@ -451,25 +467,26 @@ export default class TCaBCIClient {
     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 } : {}),
-        ...(orderField ? { order_field: orderField } : {}),
-        ...(orderBy ? { order_by: orderBy } : {}),
-        ...(types ? { types: types } : typ ? { typ: typ } : {}),
-      }),
-    })
+    return this._httpClient
+      .request('/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 } : {}),
+          ...(orderField ? { order_field: orderField } : {}),
+          ...(orderBy ? { order_by: orderBy } : {}),
+          ...(types ? { types: types } : typ ? { typ: typ } : {}),
+        }),
+      })
       .then((res) => {
         const data = []
 
@@ -484,7 +501,7 @@ export default class TCaBCIClient {
           total_count: res.total_count,
         }
       })
-      .catch((e) => this._handleRestError(e))
+      .catch((e) => this._httpClient.handleError(e))
   }
 
   /**
@@ -630,9 +647,8 @@ export default class TCaBCIClient {
       throw new Error(TRANSACTION_TYPE_NOT_VALID)
     }
 
-    return this._httpClient(
-      commit ? '/v1/tx/commit' : sync ? '/v1/tx/sync' : '/v1/tx',
-      {
+    return this._httpClient
+      .request(commit ? '/v1/tx/commit' : sync ? '/v1/tx/sync' : '/v1/tx', {
         method: 'POST',
         body: JSON.stringify({
           id,
@@ -646,13 +662,14 @@ export default class TCaBCIClient {
           sign,
           fee,
         }),
-      },
-    )
+      })
       .then((res) => {
         return { data: res.data }
       })
       .catch((e) =>
-        this._handleRestError(e, { 400: new Error(TRANSACTION_NOT_BROADCAST) }),
+        this._httpClient.handleError(e, {
+          400: new Error(TRANSACTION_NOT_BROADCAST),
+        }),
       )
   }
 
@@ -672,7 +689,7 @@ export default class TCaBCIClient {
     chainName = null,
     chainVersion = null,
   ) {
-    return this._httpClient('/v1/bulk_tx', {
+    return this._httpClient.request('/v1/bulk_tx', {
       method: 'POST',
       body: JSON.stringify({
         chain_name: chainName ?? this._chainName,
@@ -708,10 +725,6 @@ export default class TCaBCIClient {
     })
 
     this._ws.addMessageListener((message) => {
-      if (message.data === 'OK' && message.data.length < 10) {
-        return { status: message.data }
-      }
-
       this._callListenCallback(message.data)
     })
 
@@ -788,73 +801,48 @@ export default class TCaBCIClient {
   }
 
   _callListenCallback(message) {
-    const { transaction, error } = Transaction.FromJSON(message)
-    if (error) this._callErrorCallback(error)
-    else if (this._listenCb) this._listenCb(transaction)
-  }
-
-  /**
-   * @param {string} uri
-   * @param {RequestInit} req
-   * @return {Promise<Record<string, any>>}
-   */
-  _httpClient(uri, req) {
-    req.cache = 'no-cache'
-    req.headers = {
-      Client: `tcabaci-read-js-client/${this._version}`,
-    }
-    req.priority = 'high'
-
-    return fetch(this._readNodeAddress + uri, req).then((response) =>
-      this._handleRestResponse(response),
-    )
-  }
-
-  /**
-   * @param {Response} response
-   * @return {Promise<*>}
-   */
-  async _handleRestResponse(response) {
-    if (response.status >= 200 && response.status < 400) {
-      return response.json()
-    }
-
-    try {
-      const data = JSON.parse(await response.text())
-
-      return Promise.reject(
-        new FetchError(data.message)
-          .setStatus(response.status)
-          .setResponse(data),
-      )
-    } catch (e) {
-      return Promise.reject(
-        new FetchError(response.statusText).setOriginError(e),
-      )
-    }
-  }
-
-  /**
-   * @param {Error} err
-   * @param {?Object|Error} custom
-   * @throws Error
-   */
-  _handleRestError(err, custom = null) {
-    const code = err.code
-
-    if (custom && typeof custom === 'object' && custom[code]) {
-      throw custom[code]
-    } else if (custom instanceof Error) {
-      throw custom
-    }
+    let msg
+
+    const { transaction, error: e1 } = Transaction.FromJSON(message)
+    if (e1) {
+      const { message: _msg, error: e2 } = Message.FromJSON(message)
+      if (e2) {
+        this._callErrorCallback(e2)
+        return
+      }
 
-    switch (code) {
-      case 400:
-        throw new Error(INVALID_ARGUMENTS)
-      case 'ERR_NETWORK':
-        throw new Error(ERR_NETWORK)
-      default:
-        throw err
+      switch (_msg.type) {
+        case MBlock:
+          msg = Block.FromObject(_msg.data)
+          if (msg.error) {
+            this._callErrorCallback(msg.error)
+            return
+          }
+
+          if (this._listenCb) this._listenCb(msg.block, null, null)
+          break
+        case MTransaction:
+          msg = Transaction.FromObject(_msg.data)
+          if (msg.error) {
+            this._callErrorCallback(msg.error)
+            return
+          }
+
+          if (this._listenCb) this._listenCb(null, msg.transaction, null)
+          break
+        case Subscription:
+          if (message.state === OK) {
+            this._setSubscribed(true)
+          } else {
+            this._setSubscribed(false)
+          }
+          break
+        default:
+          if (this._listenCb) this._listenCb(null, null, _msg)
+          break
+      }
+    } else {
+      if (this._listenCb) this._listenCb(null, transaction, null)
     }
   }
 }

package/constants.d.ts

@@ -1,8 +1,2 @@
-export declare type MessageType = string
-
-export declare const SUBSCRIBEMessage: MessageType,
-  UNSUBSCRIBEMessage: MessageType
-
-export declare const CHARACTERS: string,
-  READ_NODE_ADDRESS: string,
+export declare const READ_NODE_ADDRESS: string,
   READ_NODE_WS_ADDRESS: string

package/errors.js

@@ -12,6 +12,24 @@ export const ALREADY_CONNECTED = 'Already connected',
   TRANSACTION_TYPE_NOT_VALID = 'Transaction type is not valid',
   TRANSACTION_NOT_BROADCAST = 'Transaction can not be broadcast'
 
+export class CopiedError extends Error {
+  originName
+  originError
+  originStack
+
+  /**
+   * @param {Error} err
+   */
+  constructor(err) {
+    super(err.message)
+    this.name = 'CopiedError'
+    this.originName = err.name
+    this.originError = err
+    this.stack = err.stack
+    this.originStack = err.stack
+  }
+}
+
 export class FetchError extends Error {
   status = -1
   response

package/http.d.ts

@@ -0,0 +1,9 @@
+import { Request } from 'express'
+
+export declare class HTTP {
+  constructor(baseURL: string)
+  setBaseURL(baseURL: string): HTTP
+  request(uri: string, req: Request): Promise<Record<string, any>>
+  handleResponse(response: Response): Promise<any>
+  handleError(err: Error, custom: Record<string, any>|Error): Promise<any>
+}

package/http.js

@@ -0,0 +1,81 @@
+import { ERR_NETWORK, FetchError, INVALID_ARGUMENTS } from './errors.js'
+import { Breaker } from './breaker.js'
+
+export class HTTP {
+  _baseURL
+  _version = 'v2.7.1'
+  _breaker = new Breaker()
+  constructor(baseURL = null) {
+    this._baseURL = baseURL
+  }
+  setBaseURL(baseURL) {
+    this._baseURL = baseURL
+    return this
+  }
+  /**
+   * @param {string} uri
+   * @param {RequestInit} req
+   * @return {Promise<Record<string, any>>}
+   */
+  async request(uri, req) {
+    req.cache = 'no-cache'
+    req.headers = {
+      Client: `tcabaci-read-js-client/${this._version}`,
+    }
+    req.priority = 'high'
+
+    return this._breaker
+      .execute(() => {
+        return fetch(this._baseURL + uri, req)
+      })
+      .then((response) => this.handleResponse(response))
+  }
+
+  /**
+   * @param {Response} response
+   * @return {Promise<*>}
+   */
+  async handleResponse(response) {
+    if (response.status >= 200 && response.status < 400) {
+      return response.json()
+    }
+
+    try {
+      const data = JSON.parse(await response.text())
+
+      return Promise.reject(
+        new FetchError(data.message)
+          .setStatus(response.status)
+          .setResponse(data),
+      )
+    } catch (e) {
+      return Promise.reject(
+        new FetchError(response.statusText).setOriginError(e),
+      )
+    }
+  }
+
+  /**
+   * @param {Error} err
+   * @param {?Object|Error} custom
+   * @return {Promise<Error>}
+   */
+  async handleError(err, custom = null) {
+    const code = err.code
+
+    if (custom && typeof custom === 'object' && custom[code]) {
+      return Promise.reject(custom[code])
+    } else if (custom instanceof Error) {
+      return Promise.reject(custom)
+    }
+
+    switch (code) {
+      case 400:
+        return Promise.reject(new Error(INVALID_ARGUMENTS))
+      case 'ERR_NETWORK':
+        return Promise.reject(new Error(ERR_NETWORK))
+      default:
+        return Promise.reject(err)
+    }
+  }
+}

package/message.d.ts

@@ -1,13 +1,46 @@
-import { MessageType } from './constants'
 import { TXType } from './transaction'
 
+export declare type MessageType = string
+
+export declare const SUBSCRIBEMessage: MessageType,
+  UNSUBSCRIBEMessage: MessageType
+
+export declare type MType =  number
+
+export declare const Block: MessageType,
+  Transaction: MessageType,
+  Subscription: MessageType,
+  Listen: MessageType,
+  MSG: MessageType
+
+export declare type MState = number
+
+export declare const OK: MState,
+  FAIL: MState
+
 export declare class Message {
-  constructor(
-    isWeb: boolean,
-    type: MessageType,
-    addrs: string[],
-    signedData?: Record<string, string>,
-    txTypes?: TXType[],
-  )
+  constructor({
+    isWeb,
+    type,
+    addrs,
+    signedData,
+    txTypes,
+  }?: {
+    isWeb: boolean
+    type: MessageType
+    addrs: string[]
+    signedData?: Record<string, string>
+    txTypes?: TXType[]
+  })
+  get IsWeb(): boolean
+  get Type(): MessageType
+  get Addresses(): string[] | null
+  get SignedAddresses(): Record<string, string> | null
+  get TXTypes(): TXType[] | null
+  get Data(): any | null
+  get State(): MState | null
+
+  static FromJSON(value: string): { message?: Message; error?: Error }
+  static FromObject(obj: Record<string, any>): { message?: Message; error?: Error }
   ToJSON(): string
 }

package/message.js

@@ -1,29 +1,115 @@
-import { INVALID_ARGUMENTS, INVALID_ARGUMENT_WITH_CS } from './errors.js'
+import { INVALID_ARGUMENT_WITH_CS } from './errors.js'
 import { TX_TYPE_LIST } from './transaction.js'
 
 export const SUBSCRIBEMessage = 'subscribe',
   UNSUBSCRIBEMessage = 'unsubscribe'
 
+export const Block = 0,
+  Transaction = 1,
+  Subscription = 2,
+  Listen = 3,
+  MSG = 4
+
+export const OK = 1,
+  FAIL = 2
+
 export default class Message {
   _is_web = false
-  _type = ''
-  _addrs = []
-  _signedData = {}
-  _txTypes = []
+  _type
+  _addresses
+  _signedAddresses
+  _txTypes
+  _data
+  _state
 
   /**
    * @param {boolean} isWeb
-   * @param {string} type
+   * @param {string|number} type
    * @param {Array<string>} addrs
    * @param {?Object} signedData
    * @param {?Array<string>} txTypes
+   * @param {*} data
    */
-  constructor(isWeb, type, addrs, signedData = null, txTypes = null) {
+  constructor({
+    isWeb,
+    type,
+    addrs,
+    signedData = null,
+    txTypes = null,
+    data = null,
+  } = {}) {
     this._is_web = isWeb
     this._type = type
-    if (addrs && Array.isArray(addrs)) this._addrs = addrs
-    if (typeof signedData === 'object') this._signedData = signedData
+    if (addrs && Array.isArray(addrs)) this._addresses = addrs
+    if (typeof signedData === 'object') this._signedAddresses = signedData
     if (txTypes && Array.isArray(txTypes)) this._txTypes = txTypes
+    if (data) this._data = data
+  }
+
+  get IsWeb() {
+    return this._is_web
+  }
+
+  get Type() {
+    return this._type
+  }
+
+  get Addresses() {
+    return this._addresses
+  }
+
+  get SignedAddresses() {
+    return this._signedAddresses
+  }
+
+  get Data() {
+    return this._data
+  }
+
+  get State() {
+    return this._state
+  }
+
+  static FromJSON(value) {
+    try {
+      const msg = new Message(),
+        parsed = JSON.parse(value)
+
+      msg._type = parsed.type
+      if (typeof parsed.addresses !== 'undefined')
+        msg._addresses = parsed.addresses
+      if (typeof parsed.signed_addresses !== 'undefined')
+        msg._signedAddresses = parsed.signed_addresses
+      if (typeof parsed.data !== 'undefined') msg._data = parsed.data
+      if (typeof parsed.tx_types !== 'undefined') msg._txTypes = parsed.tx_types
+      if (typeof parsed.state !== 'undefined') msg._state = parsed.state
+
+      msg._validate()
+
+      return { message: this, error: null }
+    } catch (e) {
+      return { message: null, error: e }
+    }
+  }
+
+  static FromObject(obj) {
+    try {
+      const msg = new Message()
+
+      msg._type = obj.type
+      if (typeof obj.addresses !== 'undefined') msg._addresses = obj.addresses
+      if (typeof obj.signed_addresses !== 'undefined')
+        msg._signedAddresses = obj.signed_addresses
+      if (typeof obj.data !== 'undefined') msg._data = obj.data
+      if (typeof obj.tx_types !== 'undefined') msg._txTypes = obj.tx_types
+      if (typeof obj.state !== 'undefined') msg._state = obj.state
+
+      msg._validate()
+
+      return { message: this, error: null }
+    } catch (e) {
+      return { message: null, error: e }
+    }
   }
 
   ToJSON() {
@@ -32,39 +118,66 @@ export default class Message {
     return JSON.stringify({
       is_web: this._is_web,
       type: this._type,
-      addrs: this._addrs,
-      signed_addrs: this._signedData,
-      ...(this._txTypes.length > 0 ? { tx_types: this._txTypes } : {}),
+      ...(this._addresses ? { addresses: this._addresses } : {}),
+      ...(this._signedAddresses
+        ? { signed_addresses: this._signedAddresses }
+        : {}),
+      ...(this._txTypes ? { tx_types: this._txTypes } : {}),
+      ...(this._data ? { data: this._data } : {}),
     })
   }
 
   _validate() {
-    if (typeof this._is_web !== 'boolean') {
+    if (
+      typeof this._is_web !== 'undefined' &&
+      typeof this._is_web !== 'boolean'
+    ) {
       throw new Error(INVALID_ARGUMENT_WITH_CS('is_web'))
     }
 
-    if (typeof this._type !== 'string') {
+    if (typeof this._type === 'undefined') {
       throw new Error(INVALID_ARGUMENT_WITH_CS('type'))
+    } else {
+      if (
+        typeof this._type === 'string' &&
+        ![SUBSCRIBEMessage, UNSUBSCRIBEMessage].includes(this._type)
+      ) {
+        throw new Error(INVALID_ARGUMENT_WITH_CS('type'))
+      } else if (
+        typeof this._type === 'number' &&
+        ![Block, Transaction, Subscription, Listen, MSG].includes(this._type)
+      ) {
+        throw new Error(INVALID_ARGUMENT_WITH_CS('type'))
+      }
     }
 
-    if (!Array.isArray(this._addrs)) {
-      throw new Error(INVALID_ARGUMENT_WITH_CS('addrs'))
-    }
-
-    if (typeof this._signedData !== 'object') {
-      throw new Error(INVALID_ARGUMENT_WITH_CS('signedData'))
+    if (
+      typeof this._addresses !== 'undefined' &&
+      !Array.isArray(this._addresses)
+    ) {
+      throw new Error(INVALID_ARGUMENT_WITH_CS('addresses'))
     }
 
-    if (![SUBSCRIBEMessage, UNSUBSCRIBEMessage].includes(this._type)) {
-      throw new Error(INVALID_ARGUMENTS)
+    if (
+      typeof this._signedAddresses !== 'undefined' &&
+      typeof this._signedAddresses !== 'object'
+    ) {
+      throw new Error(INVALID_ARGUMENT_WITH_CS('signedAddresses'))
     }
 
-    if (this._txTypes.length) {
+    if (typeof this._txTypes !== 'undefined' && this._txTypes.length) {
       for (let i = 0; i < this._txTypes.length; i++) {
         if (!TX_TYPE_LIST.includes(this._txTypes[i])) {
           throw new Error(INVALID_ARGUMENT_WITH_CS('tx_types'))
         }
       }
     }
+
+    if (
+      typeof this._state !== 'undefined' &&
+      ![OK, FAIL].includes(this._state)
+    ) {
+      throw new Error(INVALID_ARGUMENT_WITH_CS('state'))
+    }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tchain/tcabci-read-js-client",
-  "version": "2.6.6",
+  "version": "2.7.1",
   "description": "TransferChain Fastest Read Network WebSocket Client",
   "main": "client.js",
   "type": "module",
@@ -11,6 +11,9 @@
   "files": [
     "*.d.ts",
     "constants.js",
+    "breaker.js",
+    "http.js",
+    "block.js",
     "client.js",
     "errors.js",
     "message.js",
@@ -42,6 +45,7 @@
     "ws": "^8.20.0"
   },
   "dependencies": {
+    "cockatiel": "^3.2.1",
     "reconnecting-websocket": "^4.4.0"
   },
   "scripts": {

package/transaction.js

@@ -275,6 +275,8 @@ export class Transaction {
       if (typeof parsed.chain_version !== 'undefined')
         this._chainVersion = parsed.chain_version
 
+      tx.Validate()
+
       return { transaction: tx, error: null }
     } catch (e) {
       return { transaction: null, error: e }
@@ -309,10 +311,11 @@ export class Transaction {
       tx._hash = obj.hash
       if (typeof obj.inserted_at !== 'undefined')
         tx._inserted_at = new Date(obj.inserted_at)
-      if (typeof obj.chain_name !== 'undefined')
-        this._chainName = obj.chain_name
+      if (typeof obj.chain_name !== 'undefined') tx._chainName = obj.chain_name
       if (typeof obj.chain_version !== 'undefined')
-        this._chainVersion = obj.chain_version
+        tx._chainVersion = obj.chain_version
+
+      tx.Validate()
 
       return { transaction: tx, error: null }
     } catch (e) {

package/websocketOptions.js

@@ -13,7 +13,7 @@ export class Options {
   _protocols = []
   _customWS
   _endpoints = ['ws', 'longpoll']
-  _version = `v2.6.6`
+  _version = `v2.7.1`
 
   _maxConnectionDelay = 10000
   _minReconnectionDelay = 1000 + Math.random() * 4000