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

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/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

@@ -11,10 +11,18 @@ 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'
 
 /**
  * @callback SuccessCallback
@@ -36,7 +44,9 @@ import { Transaction, TX_TYPE_LIST } from './transaction.js'
 
 /**
  * @callback ListenCallback
- * @param {*} message
+ * @param {?Block} block
+ * @param {?Transaction} transaction
+ * @param {?*} msg
  * @return void
  */
 
@@ -47,7 +57,7 @@ export default class TCaBCIClient {
   _connected = false
   _chainName = 'transferchain'
   _chainVersion = 'v1'
-  _version = `v2.6.6`
+  _version = `v2.7.0`
   /**
    * @type {?SuccessCallback}
    */
@@ -258,18 +268,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 +290,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([])
@@ -708,10 +720,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,9 +796,49 @@ export default class TCaBCIClient {
   }
 
   _callListenCallback(message) {
-    const { transaction, error } = Transaction.FromJSON(message)
-    if (error) this._callErrorCallback(error)
-    else if (this._listenCb) this._listenCb(transaction)
+    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 (_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/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.0",
   "description": "TransferChain Fastest Read Network WebSocket Client",
   "main": "client.js",
   "type": "module",
@@ -11,6 +11,7 @@
   "files": [
     "*.d.ts",
     "constants.js",
+    "block.js",
     "client.js",
     "errors.js",
     "message.js",

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.0`
 
   _maxConnectionDelay = 10000
   _minReconnectionDelay = 1000 + Math.random() * 4000