@tchain/tcabci-read-js-client 2.5.5 → 2.5.7

package/bytea.d.ts

@@ -0,0 +1,4 @@
+export declare class Bytea {
+  constructor(bytes: Uint8Array, status: number)
+  ToJSON(): string
+}

package/client.d.ts

@@ -0,0 +1,112 @@
+import { TXType } from './transaction'
+
+declare class TCaBCIClient {
+  constructor(
+    readNodeAddresses: string[],
+    wsLibrary: WebSocket,
+    chainName: string,
+    chainVersion: string,
+  )
+
+  SetDebug(debug: boolean): TCaBCIClient
+  Socket(): WebSocket
+  SetSuccessCallback(cb: (event: Event) => void): TCaBCIClient
+  SetErrorCallback(cb: (event: Event) => void): TCaBCIClient
+  SetCloseCallback(cb: (event: Event) => void): TCaBCIClient
+  SetListenCallback(cb: (event: Event) => void): TCaBCIClient
+  Start(): Awaited<TCaBCIClient>
+  Stop(): Awaited<TCaBCIClient>
+  Status(): {
+    chain_name: string
+    chain_version: string
+    connected: boolean
+    subscribed: boolean
+  }
+  Subscribe(
+    addresses: string[],
+    signedData: Record<string, string>,
+    txTypes?: TXType[],
+  ): TCaBCIClient
+  Unsubscribe(): TCaBCIClient
+  LastBlock(
+    chainName?: null,
+    chainVersion?: null,
+  ): { blocks: Record<string, any>; total_count: number }
+  Tx(id: string, signature: string): Promise<{ tx: Record<string, any> }>
+  TxSummary({
+    recipientAddrs,
+    senderAddrs,
+    signedData,
+    typ,
+    types,
+    chainName,
+    chainVersion,
+  }: Record<string, any>): Promise<{
+    chain_name: string
+    chain_version: string
+    first_block_height: number
+    first_transaction: Record<string, any>
+    last_block_height: number
+    last_transaction: Record<string, any>
+    total_count: number
+  }>
+  TxSearch({
+    heightOperator,
+    height,
+    maxHeight,
+    lastOrder,
+    recipientAddrs,
+    senderAddrs,
+    signedData,
+    hashes,
+    typ,
+    types,
+    limit,
+    offset,
+    orderField,
+    orderBy,
+    chainName,
+    chainVersion,
+  }): Promise<{ txs: Record<string, any>[]; total_count: number }>
+  BroadcastCommit({
+    id,
+    version,
+    type,
+    data,
+    sender_addr,
+    recipient_addr,
+    sign,
+    fee,
+  }): Promise<{ data: Record<string, any> }>
+  BroadcastSync({
+    id,
+    version,
+    type,
+    data,
+    sender_addr,
+    recipient_addr,
+    sign,
+    fee,
+  }): Promise<{ data: Record<string, any> }>
+  Broadcast({
+    id,
+    version,
+    type,
+    data,
+    sender_addr,
+    recipient_addr,
+    sign,
+    fee,
+  }): Promise<{ data: Record<string, any> }>
+  Bulk(
+    addresses: string[],
+    signedData: Record<string, any>,
+    maxHeight?: number,
+    chainName?: string,
+    chainVersion?: string,
+  ): Promise<{ data: Record<string, any> }>
+  Disconnect(code?: number): Awaited<TCaBCIClient>
+  Reconnect(code?: number): Awaited<TCaBCIClient>
+}
+
+export = TCaBCIClient

package/client.js

@@ -1,9 +1,8 @@
 import {
-  ADDRESSES_IS_EMPTY,
+  FetchError,
   ALREADY_CONNECTED,
   BLOCK_NOT_FOUND,
   ERR_NETWORK,
-  FetchError,
   INVALID_ARGUMENT_WITH_CS,
   INVALID_ARGUMENTS,
   NOT_CONNECTED,
@@ -12,12 +11,13 @@ import {
   TRANSACTION_TYPE_NOT_VALID,
 } from './errors.js'
 import {
-  MESSAGE_TYPE,
+  SUBSCRIBEMessage,
+  UNSUBSCRIBEMessage,
   READ_NODE_ADDRESS,
   READ_NODE_WS_ADDRESS,
 } from './constants.js'
 import Message from './message.js'
-import { isJSON, toJSON } from './util.js'
+import { isJSON, fromJSON } from './util.js'
 import { Options } from './websocketOptions.js'
 import { TWebSocket } from './websocket.js'
 import { TX_TYPE, TX_TYPE_LIST } from './transaction.js'
@@ -49,7 +49,7 @@ export default class TCaBCIClient {
   _connected = false
   _chainName = 'transferchain'
   _chainVersion = 'v1'
-  _version = `v2.5.5`
+  _version = `v2.5.7`
   /**
    * @type {?successCallback}
    */
@@ -67,6 +67,11 @@ export default class TCaBCIClient {
    */
   _listenCb = null
   _wsLibrary = null
+  /**
+   * @type {Options}
+   * @private
+   */
+  _options
   /**
    * @type {TWebSocket}
    */
@@ -90,34 +95,25 @@ export default class TCaBCIClient {
     this._wsLibrary = wsLibrary
 
     if (Array.isArray(readNodeAddresses) && readNodeAddresses.length === 2) {
-      this._readNodeAddress = readNodeAddresses[0]
-      this._readNodeWSAddress = readNodeAddresses[1]
-
       if (!readNodeAddresses[0].startsWith('http'))
         throw new Error(INVALID_ARGUMENTS)
       if (!readNodeAddresses[1].startsWith('ws'))
         throw new Error(INVALID_ARGUMENTS)
+
+      this._readNodeAddress = readNodeAddresses[0]
+      this._readNodeWSAddress = readNodeAddresses[1]
     }
 
+    this._options = new Options(this._readNodeWSAddress)
+    this._options.setCustomWS(this._wsLibrary)
+
     if (chainName) this._chainName = chainName
     if (chainVersion) this._chainVersion = chainVersion
   }
 
-  /**
-   * @param {string} uri
-   * @param {RequestInit} req
-   * @return {Promise<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),
-    )
+  SetDebug(debug) {
+    this._options.setDebug(debug)
+    return this
   }
 
   Socket() {
@@ -126,7 +122,7 @@ export default class TCaBCIClient {
 
   /**
    * @param {successCallback} cb
-   * @constructor
+   * @return {TCaBCIClient}
    */
   SetSuccessCallback(cb) {
     this._successCb = cb
@@ -136,7 +132,7 @@ export default class TCaBCIClient {
 
   /**
    * @param {errorCallback} cb
-   * @constructor
+   * @return {TCaBCIClient}
    */
   SetErrorCallback(cb) {
     this._errorCb = cb
@@ -146,7 +142,7 @@ export default class TCaBCIClient {
 
   /**
    * @param {closeCallback} cb
-   * @constructor
+   * @return {TCaBCIClient}
    */
   SetCloseCallback(cb) {
     this._closeCb = cb
@@ -156,7 +152,7 @@ export default class TCaBCIClient {
 
   /**
    * @param {listenCallback} cb
-   * @constructor
+   * @return {TCaBCIClient}
    */
   SetListenCallback(cb) {
     this._listenCb = cb
@@ -183,6 +179,15 @@ export default class TCaBCIClient {
     return this
   }
 
+  Status() {
+    return {
+      chain_name: this._chainName,
+      chain_version: this._chainVersion,
+      connected: this._connected,
+      subscribed: this._subscribed,
+    }
+  }
+
   /**
    * @param {Array<string>} addresses
    * @param {Object} signedData
@@ -232,13 +237,7 @@ export default class TCaBCIClient {
       sdata = this.getSubscribedSignedData()
     }
 
-    const message = new Message(
-      true,
-      MESSAGE_TYPE.SUBSCRIBE,
-      addrs,
-      sdata,
-      txTypes,
-    )
+    const message = new Message(true, SUBSCRIBEMessage, addrs, sdata, txTypes)
 
     this._ws.send(message.ToJSON())
     this.setSubscribeAddresses(addrs, true)
@@ -248,6 +247,9 @@ export default class TCaBCIClient {
     return this
   }
 
+  /**
+   * @return {TCaBCIClient}
+   */
   Unsubscribe() {
     if (!this.getSubscribed()) {
       throw new Error(NOT_SUBSCRIBED)
@@ -255,22 +257,24 @@ export default class TCaBCIClient {
     this._ws.send(
       new Message(
         true,
-        MESSAGE_TYPE.UNSUBSCRIBE,
+        UNSUBSCRIBEMessage,
         this.getSubscribeAddresses(),
       ).ToJSON(),
     )
     this.setSubscribed(false)
     this.setSubscribeAddresses([])
     this.setSubscribeSignedData({})
+
+    return this
   }
 
   /**
    * @param {?string} chainName
    * @param {?string} chainVersion
-   * @return {Promise<any>}
+   * @return {Promise<{blocks: Object<string, *>, total_count: number}>}
    */
   LastBlock(chainName = null, chainVersion = null) {
-    return this.httpClient(
+    return this._httpClient(
       `/v1/blocks?chain_name=${chainName ?? this._chainName}&chain_version=${chainVersion ?? this._chainVersion}&limit=1&offset=0`,
       {
         method: 'GET',
@@ -279,7 +283,7 @@ export default class TCaBCIClient {
       .then((res) => {
         return { blocks: res.data, total_count: res.total_count }
       })
-      .catch((e) => this.handleRestError(e, new Error(BLOCK_NOT_FOUND)))
+      .catch((e) => this._handleRestError(e, new Error(BLOCK_NOT_FOUND)))
   }
 
   /**
@@ -292,14 +296,14 @@ export default class TCaBCIClient {
       return Promise.reject(new Error(INVALID_ARGUMENTS))
     }
 
-    return this.httpClient(`/v1/tx/${id}`, {
+    return this._httpClient(`/v1/tx/${id}`, {
       method: 'GET',
       headers: { 'X-Signature': signature },
     })
       .then((res) => {
         return { tx: res.data }
       })
-      .catch((e) => this.handleRestError(e))
+      .catch((e) => this._handleRestError(e))
   }
 
   /**
@@ -325,7 +329,7 @@ export default class TCaBCIClient {
       return Promise.reject(new Error(INVALID_ARGUMENTS))
     }
 
-    return this.httpClient('/v1/tx_summary', {
+    return this._httpClient('/v1/tx_summary', {
       method: 'POST',
       body: JSON.stringify({
         chain_name: chainName ?? this._chainName,
@@ -347,7 +351,7 @@ export default class TCaBCIClient {
           total_count: res.total_count,
         }
       })
-      .catch((e) => this.handleRestError(e))
+      .catch((e) => this._handleRestError(e))
   }
 
   /**
@@ -387,7 +391,7 @@ export default class TCaBCIClient {
     chainName = null,
     chainVersion = null,
   }) {
-    return this.httpClient('/v1/tx_search/p', {
+    return this._httpClient('/v1/tx_search/p', {
       method: 'POST',
       body: JSON.stringify({
         chain_name: chainName ?? this._chainName,
@@ -412,16 +416,7 @@ export default class TCaBCIClient {
           total_count: res.total_count,
         }
       })
-      .catch((e) => this.handleRestError(e))
-  }
-
-  Status() {
-    return {
-      chain_name: this._chainName,
-      chain_version: this._chainVersion,
-      connected: this._connected,
-      subscribed: this._subscribed,
-    }
+      .catch((e) => this._handleRestError(e))
   }
 
   /**
@@ -544,7 +539,7 @@ export default class TCaBCIClient {
       throw new Error(TRANSACTION_TYPE_NOT_VALID)
     }
 
-    return this.httpClient(
+    return this._httpClient(
       commit ? '/v1/tx/commit' : sync ? '/v1/tx/sync' : '/v1/tx',
       {
         method: 'POST',
@@ -564,7 +559,7 @@ export default class TCaBCIClient {
         return { data: res.data }
       })
       .catch((e) =>
-        this.handleRestError(e, { 400: new Error(TRANSACTION_NOT_BROADCAST) }),
+        this._handleRestError(e, { 400: new Error(TRANSACTION_NOT_BROADCAST) }),
       )
   }
 
@@ -584,7 +579,7 @@ export default class TCaBCIClient {
     chainName = null,
     chainVersion = null,
   ) {
-    return this.httpClient('/v1/bulk_tx', {
+    return this._httpClient('/v1/bulk_tx', {
       method: 'POST',
       body: JSON.stringify({
         chain_name: chainName ?? this._chainName,
@@ -596,6 +591,10 @@ export default class TCaBCIClient {
     })
   }
 
+  /**
+   * @param {?number} code
+   * @return {Promise<TCaBCIClient>}
+   */
   async Disconnect(code = 1000) {
     if (this.getConnected()) {
       await this._ws.disconnect(code)
@@ -603,6 +602,8 @@ export default class TCaBCIClient {
       this.setConnected(false)
       this.setSubscribed(false)
     }
+
+    return this
   }
 
   async Reconnect(code = 1000) {
@@ -639,10 +640,7 @@ export default class TCaBCIClient {
       return Promise.reject(new Error(ALREADY_CONNECTED))
     }
 
-    const options = new Options(this._readNodeWSAddress)
-    options.setCustomWS(this._wsLibrary)
-
-    this._ws = new TWebSocket(options)
+    this._ws = new TWebSocket(this._options)
 
     this._ws.addErrorListener((e) => {
       this.setConnected(false)
@@ -663,7 +661,7 @@ export default class TCaBCIClient {
       }
 
       this.callListenCallback(
-        !isJSON(message.data) ? message.data : toJSON(message.data),
+        !isJSON(message.data) ? message.data : fromJSON(message.data),
       )
     })
 
@@ -728,25 +726,44 @@ export default class TCaBCIClient {
     return this
   }
 
+  /**
+   * @param {string} uri
+   * @param {RequestInit} req
+   * @return {Promise<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) {
+  async _handleRestResponse(response) {
     if (response.status >= 200 && response.status < 400) {
       return response.json()
     }
 
-    let data = await response.text()
-
     try {
-      data = JSON.parse(data)
+      const data = JSON.parse(await response.text())
 
       return Promise.reject(
-        new FetchError(data.message).setCode(response.status).setResponse(data),
+        new FetchError(data.message)
+          .setStatus(response.status)
+          .setResponse(data),
       )
     } catch (e) {
-      return Promise.reject(new FetchError(response.statusText))
+      return Promise.reject(
+        new FetchError(response.statusText).setOriginError(e),
+      )
     }
   }
 
@@ -755,7 +772,7 @@ export default class TCaBCIClient {
    * @param {?Object|Error} custom
    * @throws Error
    */
-  handleRestError(err, custom = null) {
+  _handleRestError(err, custom = null) {
     const code = err.code
 
     if (custom && typeof custom === 'object' && custom[code]) {

package/constants.d.ts

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

package/constants.js

@@ -1,7 +1,5 @@
-export const MESSAGE_TYPE = {
-    SUBSCRIBE: 'subscribe',
-    UNSUBSCRIBE: 'unsubscribe',
-  },
+export const SUBSCRIBEMessage = 'subscribe',
+  UNSUBSCRIBEMessage = 'unsubscribe',
   CHARACTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789',
   READ_NODE_ADDRESS = 'https://read-node-01.transferchain.io',
   READ_NODE_WS_ADDRESS = 'wss://read-node-01.transferchain.io/ws'

package/errors.d.ts

@@ -0,0 +1,24 @@
+export declare type ErrMessage = string
+
+export declare const ALREADY_CONNECTED: ErrMessage,
+  NOT_CONNECTED: ErrMessage,
+  ERR_NETWORK: ErrMessage,
+  INVALID_ARGUMENTS: ErrMessage,
+  INVALID_ARGUMENT_WITH_CS: (val: string) => ErrMessage,
+  NOT_SUBSCRIBED: ErrMessage,
+  ALREADY_SUBSCRIBED: ErrMessage,
+  ADDRESSES_IS_EMPTY: ErrMessage,
+  BLOCK_NOT_FOUND: ErrMessage,
+  TRANSACTION_TYPE_NOT_VALID: ErrMessage,
+  TRANSACTION_NOT_BROADCAST: ErrMessage
+
+export declare class FetchError extends Error {
+  code: number
+  response: Record<string, any>
+  originError?: Error
+  constructor(message: string)
+  setStatus(status: number): FetchError
+  setCode(code: number): FetchError
+  setResponse(data: Record<string, any>): FetchError
+  setOriginError(error: Error): FetchError
+}

package/errors.js

@@ -13,8 +13,9 @@ export const ALREADY_CONNECTED = 'Already connected',
   TRANSACTION_NOT_BROADCAST = 'Transaction can not be broadcast'
 
 export class FetchError extends Error {
-  code = -1
-  response = {}
+  status = -1
+  response
+  originError
 
   /**
    * @param {string} message
@@ -24,18 +25,35 @@ export class FetchError extends Error {
     this.name = 'FetchError'
   }
 
+  /**
+   * @param {number} status
+   * @return {FetchError}
+   */
+  setStatus(status) {
+    this.status = status
+
+    return this
+  }
+
+  /**
+   * @deprecated use .setStatus/1
+   * @param {number} code
+   * @return {FetchError}
+   */
   setCode(code) {
-    this.code = code
+    this.status = code
 
     return this
   }
 
   setResponse(data) {
-    this.response = {
-      status: this.code,
-      message: this.message,
-      data: data,
-    }
+    this.response = data
+
+    return this
+  }
+
+  setOriginError(error) {
+    this.originError = error
 
     return this
   }

package/errors_test.js

@@ -3,7 +3,7 @@ import unitJS from 'unit.js'
 
 describe('Errors', () => {
   it('FetchError', () => {
-    const err = new FetchError('err1').setCode(1)
+    const err = new FetchError('err1').setStatus(1)
 
     unitJS.assert.equal(err.message, 'err1')
     unitJS.assert.equal(err.code, 1)

package/eslint.config.js

@@ -0,0 +1,45 @@
+import globals from 'globals'
+import pluginJs from '@eslint/js'
+import pluginPrettier from 'eslint-plugin-prettier/recommended'
+
+export default [
+  {
+    languageOptions: {
+      globals: {
+        ...globals.browser,
+        process: 'readonly',
+        global: 'readonly',
+      },
+    },
+  },
+  pluginJs.configs.recommended,
+  {
+    ignores: ['.nyc*', 'node_modules/*', 'eslint*', '*_test.js'],
+  },
+  {
+    rules: {
+      'no-console': 'error',
+      'no-debugger': 'error',
+      'no-extra-boolean-cast': 'off',
+      'no-unused-vars': [
+        'error',
+        {
+          argsIgnorePattern: '^_',
+          varsIgnorePattern: '^_',
+          caughtErrorsIgnorePattern: '^_',
+        },
+      ],
+      indent: [
+        'error',
+        2,
+        {
+          SwitchCase: 1,
+          MemberExpression: 1,
+          ImportDeclaration: 1,
+          // VariableDeclarator: { var: 2, let: 2, const: 3 },
+        },
+      ],
+    },
+  },
+  pluginPrettier,
+]

package/message.d.ts

@@ -0,0 +1,13 @@
+import { MessageType } from './constants'
+import { TXType } from './transaction'
+
+export declare class Message {
+  constructor(
+    isWeb: boolean,
+    type: MessageType,
+    addrs: string[],
+    signedData?: Record<string, string>,
+    txTypes?: TXType[],
+  )
+  ToJSON(): string
+}

package/message.js

@@ -1,5 +1,5 @@
 import { INVALID_ARGUMENTS, INVALID_ARGUMENT_WITH_CS } from './errors.js'
-import { MESSAGE_TYPE } from './constants.js'
+import { SUBSCRIBEMessage, UNSUBSCRIBEMessage } from './constants.js'
 import { TX_TYPE_LIST } from './transaction.js'
 
 export default class Message {
@@ -53,10 +53,7 @@ export default class Message {
       throw new Error(INVALID_ARGUMENT_WITH_CS('signedData'))
     }
 
-    if (
-      [MESSAGE_TYPE.SUBSCRIBE, MESSAGE_TYPE.UNSUBSCRIBE].indexOf(this._type) ===
-      -1
-    ) {
+    if (![SUBSCRIBEMessage, UNSUBSCRIBEMessage].includes(this._type)) {
       throw new Error(INVALID_ARGUMENTS)
     }
 

package/package.json

@@ -1,15 +1,9 @@
 {
   "name": "@tchain/tcabci-read-js-client",
-  "version": "2.5.5",
+  "version": "2.5.7",
   "description": "TransferChain Fastest Read Network WebSocket Client",
   "main": "client.js",
   "type": "module",
-  "scripts": {
-    "test": "export NODE_ENV=test || SET \"NODE_ENV=test\" && mocha  --require esm --timeout 5000",
-    "test:all": "export NODE_ENV=test || SET \"NODE_ENV=test\" && mocha  --require esm --timeout 5000 '*_test.js'",
-    "test:coverage": "export NODE_ENV=test || SET \"NODE_ENV=test\" && nyc --reporter=text mocha  --require esm --timeout 5000",
-    "format": "prettier --write \"**/*.{js,md,json}\" --ignore-path .gitignore"
-  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/TransferChain/tcabci-read-js-client.git"
@@ -21,12 +15,16 @@
   },
   "homepage": "https://github.com/TransferChain/tcabci-read-js-client#readme",
   "devDependencies": {
-    "@eslint/js": "^9.34.0",
-    "chai": "^6.0.1",
-    "esm": "*",
+    "@eslint/js": "^9.38.0",
+    "@types/chai": "^5.2.3",
+    "chai": "^6.2.0",
+    "eslint": "^9.38.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "esm": "^3.2.25",
     "express": "^5.1.0",
-    "globals": "^16.3.0",
-    "mocha": "^11.7.1",
+    "globals": "^16.4.0",
+    "mocha": "^11.7.4",
     "nyc": "^17.1.0",
     "prettier": "^3.6.2",
     "unit.js": "^2.1.1",
@@ -34,5 +32,12 @@
   },
   "dependencies": {
     "reconnecting-websocket": "^4.4.0"
+  },
+  "scripts": {
+    "format": "prettier --write \"**/*.{js,md,json}\" --ignore-path .gitignore",
+    "lint:fix": "eslint --fix",
+    "test": "export NODE_ENV=test || SET \"NODE_ENV=test\" && mocha  --require esm --timeout 5000",
+    "test:all": "export NODE_ENV=test || SET \"NODE_ENV=test\" && mocha  --require esm --timeout 5000 '*_test.js'",
+    "test:coverage": "export NODE_ENV=test || SET \"NODE_ENV=test\" && nyc --reporter=text mocha  --require esm --timeout 5000"
   }
-}
+}

package/transaction.d.ts

@@ -0,0 +1,84 @@
+export declare type TXType = string;
+
+export declare const TX_TYPE_MASTER: TXType,
+  TX_TYPE_ADDRESS: TXType,
+  TX_TYPE_ADDRESSES: TXType,
+  TX_TYPE_ACCOUNT: TXType,
+  TX_TYPE_ACCOUNT_INITIAL_TXS: TXType,
+  TX_TYPE_MESSAGE: TXType,
+  TX_TYPE_MESSAGE_SENT: TXType,
+  TX_TYPE_MESSAGE_THREAD_DELETE: TXType,
+  TX_TYPE_TRANSFER: TXType,
+  TX_TYPE_TRANSFER_CANCEL: TXType,
+  TX_TYPE_TRANSFER_SENT: TXType,
+  TX_TYPE_TRANSFER_RECEIVE_DELETE: TXType,
+  TX_TYPE_TRANSFER_INFO: TXType,
+  TX_TYPE_STORAGE: TXType,
+  TX_TYPE_STORAGE_DELETE: TXType,
+  TX_TYPE_BACKUP: TXType,
+  TX_TYPE_CONTACT: TXType,
+  TX_TYPE_FILE_VIRTUAL: TXType,
+  TX_TYPE_FILE_FS: TXType,
+  TX_TYPE_RFILE_VIRTUAL: TXType,
+  TX_TYPE_RFILE_FS: TXType,
+  TX_TYPE_DFILE_VIRTUAL: TXType,
+  TX_TYPE_DFILE_FS: TXType,
+  TX_TYPE_PFILE_VIRTUAL: TXType,
+  TX_TYPE_REQUEST: TXType,
+  TX_TYPE_REQUEST_IN: TXType,
+  TX_TYPE_REQUEST_UPLOAD: TXType,
+  TX_TYPE_REQUEST_CANCEL: TXType,
+  TX_TYPE_DATA_ROOM: TXType,
+  TX_TYPE_DATA_ROOMF: TXType,
+  TX_TYPE_DATA_ROOM_POLICY: TXType,
+  TX_TYPE_DATA_ROOM_DATA: TXType,
+  TX_TYPE_DATA_ROOM_DATA_DELETE: TXType,
+  TX_TYPE_DATA_ROOM_DATA_POLICY: TXType,
+  TX_TYPE_MULTI_DATA_ROOM: TXType,
+  TX_TYPE_MULTI_STORAGE: TXType,
+  TX_TYPE_MULTI_TRANSFER: TXType,
+  TX_TYPE_MULTI_TRANSFER_SENT: TXType,
+  TX_TYPE_MULTI_BACKUP: TXType,
+  TX_TYPE_MULTI_PASSWD: TXType,
+  TX_TYPE_PASSWD_DATA: TXType,
+  TX_TYPE_PASSWD_ROOM: TXType,
+  TX_TYPE_PASSWD_ROOMF: TXType,
+  TX_TYPE_PASSWD_ROOM_POLICY: TXType,
+  TX_TYPE_PASSWD_ROOM_DATA: TXType,
+  TX_TYPE_PASSWD_ROOM_DATA_DELETE: TXType,
+  TX_TYPE_PASSWD_ROOM_DATA_POLICY: TXType,
+  TX_TYPE_PASSWD_DATAV2: TXType,
+  TX_TYPE_PASSWD_DATAV2_POLICY: TXType,
+  TX_TYPE_COLLECTION: TXType,
+  TX_TYPE_COLLECTION_POLICY: TXType;
+
+export declare const TX_TYPE: Record<string, TXType>,
+  TX_TYPE_LIST: TXType[];
+
+export declare class Transaction {
+  constructor(
+    id: string,
+    height: number,
+    version: number,
+    typ: TXType,
+    sender_addr: string,
+    recipient_addr: string,
+    data: string,
+    sign: string,
+    fee: number,
+    hash: string,
+    inserted_at: Date,
+  )
+  get ID(): string;
+  get Height(): number;
+  get Version(): number;
+  get Typ(): TXType;
+  get SenderAddr(): string;
+  get RecipientAddr(): string;
+  get Data(): string;
+  get Sign(): string;
+  get Fee(): number;
+  get Hash(): string;
+  get InsertedAt(): Date;
+  ToJSON(): string;
+}

package/transaction.js

@@ -106,7 +106,7 @@ export const TX_TYPE_MASTER = 'initial_storage',
   },
   TX_TYPE_LIST = Object.keys(TX_TYPE).map((k) => TX_TYPE[k])
 
-export default class Transaction {
+export class Transaction {
   _id
   _height
   _version

package/util.d.ts

@@ -0,0 +1,2 @@
+export declare function fromJSON(data: string): Record<string, any>;
+export declare function isJSON(str: string): boolean;

package/util.js

@@ -1,11 +1,11 @@
-export function toJSON(data) {
+export function fromJSON(data) {
   return JSON.parse(data)
 }
 
 export function isJSON(str) {
   try {
     JSON.parse(str)
-  } catch (e) {
+  } catch (_e) {
     return false
   }
 

package/websocket.d.ts

@@ -0,0 +1,24 @@
+import { Options } from './websocketOptions'
+
+export declare const MaxListenerSize: number
+
+export declare class TWebSocket {
+  constructor(options: Options)
+  get ready(): boolean
+  get openListeners(): (() => void)[]
+  get messageListeners(): (() => void)[]
+  get errorListeners(): (() => void)[]
+  get closeListeners(): (() => void)[]
+  connect(force?: boolean): Awaited<TWebSocket>
+  reconnect(code: number): Awaited<TWebSocket>
+  disconnect(code: number): Awaited<TWebSocket>
+  send(message: (string|ArrayBufferLike|Blob|ArrayBufferView)): void
+  addOpenListener(callback: (event: Event) => void): TWebSocket
+  removeOpenListener(callback: (event: Event) => void): TWebSocket
+  addMessageListener(callback: (event: Event) => void): TWebSocket
+  removeMessageListener(callback: (event: Event) => void): TWebSocket
+  addErrorListener(callback: (event: Event) => void): TWebSocket
+  removeErrorListener(callback: (event: Event) => void): TWebSocket
+  addCloseListener(callback: (event: Event) => void): TWebSocket
+  removeCloseListener(callback: (event: Event) => void): TWebSocket
+}

package/websocket.js

@@ -49,28 +49,28 @@ export class TWebSocket {
   }
 
   /**
-   * @return {Array<string>}
+   * @return {Array<function>}
    */
   get openListeners() {
     return this._openCallbacks
   }
 
   /**
-   * @return {Array<string>}
+   * @return {Array<function>}
    */
   get messageListeners() {
     return this._messageCallbacks
   }
 
   /**
-   * @return {Array<string>}
+   * @return {Array<function>}
    */
   get errorListeners() {
     return this._errorCallbacks
   }
 
   /**
-   * @return {Array<string>}
+   * @return {Array<function>}
    */
   get closeListeners() {
     return this._closeCallbacks
@@ -252,8 +252,8 @@ export class TWebSocket {
 
   _make() {
     this._client = new ReconnectingWebSocket(
-      this._options.url(),
-      this._options.protocols(),
+      this._options.url,
+      this._options.protocols,
       this._options.make(),
     )
 

package/websocketOptions.d.ts

@@ -0,0 +1,50 @@
+export declare type Timeout = number
+export declare const DefaultTimeout: Timeout, LongTimeout: Timeout
+
+export declare type Port = number
+export declare const HTTPSPort: Port, HTTPPort: Port
+
+export declare class Options {
+  constructor(
+    host: string,
+    timeout: Timeout,
+    secure: boolean,
+    port: Port,
+    longpoll: boolean,
+  )
+  check(): boolean
+  isLongPool(): boolean
+  setDebug(debug: boolean): Options
+  get debug(): boolean
+  setEndpoints(wsEndpoint: string, longpollEndpoint: string): Options
+  endpoints(): string[]
+  setMaxConnectionDelay(delay: number): Options
+  get maxConnectionDelay(): number
+  setMinReconnectionDelay(delay: number): Options
+  get minReconnectionDelay(): number
+  setReconnectionDelayGrowFactor(gw: number): Options
+  get reconnectionDelayGrowFactor(): number
+  setMinUptime(ut: number): Options
+  get minUptime(): number
+  setMaxRetries(retries: number): Options
+  get maxRetries(): number
+  setMaxEnqueuedMessages(em: number): Options
+  get maxEnqueuedMessages(): number
+  setProtocols(protocols: string[]): Options
+  get protocols(): string[]
+  setCustomWS(customWS: WebSocket): Options
+  get customWS(): WebSocket | undefined
+  get url(): string
+  make(): {
+    WebSocket?: any
+    maxReconnectionDelay: number
+    minReconnectionDelay: number
+    reconnectionDelayGrowFactor: number
+    minUptime: number
+    connectionTimeout: number
+    maxRetries: number
+    maxEnqueuedMessages: number
+    startClosed: boolean
+    debug: boolean
+  }
+}

package/websocketOptions.js

@@ -13,7 +13,7 @@ export class Options {
   _protocols = []
   _customWS
   _endpoints = ['ws', 'longpoll']
-  _version = `v2.5.5`
+  _version = `v2.5.7`
 
   _maxConnectionDelay = 10000
   _minReconnectionDelay = 1000 + Math.random() * 4000
@@ -54,8 +54,9 @@ export class Options {
     if (this._timeout > LongTimeout)
       throw new Error(`timeout less than LongTimeout`)
 
+    // eslint-disable-next-line
     try {
-      new URL(this.url())
+      new URL(this.url)
 
       return true
     } catch (e) {
@@ -66,7 +67,7 @@ export class Options {
   /**
    * @return {boolean}
    */
-  isLongPool() {
+  get isLongPool() {
     // return this._longpoll
 
     return false
@@ -85,7 +86,7 @@ export class Options {
   /**
    * @return {boolean}
    */
-  debug() {
+  get debug() {
     return this._debug
   }
 
@@ -99,12 +100,14 @@ export class Options {
       throw new TypeError('invalid endpoints')
 
     this._endpoints = [wsEndpoint, longpollEndpoint]
+
+    return this
   }
 
   /**
    * @return {Array<string>}
    */
-  endpoints() {
+  get endpoints() {
     return this._endpoints
   }
 
@@ -121,7 +124,7 @@ export class Options {
   /**
    * @return {number}
    */
-  maxConnectionDelay() {
+  get maxConnectionDelay() {
     return this._maxConnectionDelay
   }
 
@@ -138,7 +141,7 @@ export class Options {
   /**
    * @return {number}
    */
-  minReconnectionDelay() {
+  get minReconnectionDelay() {
     return this._minReconnectionDelay
   }
 
@@ -155,7 +158,7 @@ export class Options {
   /**
    * @return {number}
    */
-  reconnectionDelayGrowFactor() {
+  get reconnectionDelayGrowFactor() {
     return this._reconnectionDelayGrowFactor
   }
 
@@ -172,7 +175,7 @@ export class Options {
   /**
    * @return {number}
    */
-  minUptime() {
+  get minUptime() {
     return this._minUptime
   }
 
@@ -189,7 +192,7 @@ export class Options {
   /**
    * @return {number}
    */
-  maxRetries() {
+  get maxRetries() {
     return this._maxRetries
   }
 
@@ -206,7 +209,7 @@ export class Options {
   /**
    * @return {number}
    */
-  maxEnqueuedMessages() {
+  get maxEnqueuedMessages() {
     return this._maxEnqueuedMessages
   }
 
@@ -226,7 +229,7 @@ export class Options {
   /**
    * @return {Array<string>}
    */
-  protocols() {
+  get protocols() {
     return this._protocols
   }
 
@@ -243,14 +246,14 @@ export class Options {
   /**
    * @return {any}
    */
-  customWS() {
+  get customWS() {
     return this._customWS
   }
 
   /**
    * @return {string}
    */
-  url() {
+  get url() {
     if (this._host.length > 2 && this._host.slice(0, 2) === 'ws') {
       return `${this._host}${![HTTPPort, HTTPSPort].includes(this._port) ? `:${this._port}` : ''}`
     }

package/websocketOptions_test.js

@@ -44,7 +44,7 @@ describe('Options', () => {
   it('isLongPoll/0', () => {
     const options = new Options('localhost')
 
-    expect(options.isLongPool()).to.be.equal(false)
+    expect(options.isLongPool).to.be.equal(false)
   })
 
   it('setEndpoints/2 with valid params', () => {
@@ -81,7 +81,7 @@ describe('Options', () => {
     const options = new Options('localhost')
 
     options.setProtocols(['wamp', 'soap'])
-    expect(options.protocols()).to.have.deep.members(['wamp', 'soap'])
+    expect(options.protocols).to.have.deep.members(['wamp', 'soap'])
   })
 
   it('setCustomWS/1 with valid params', () => {
@@ -94,25 +94,25 @@ describe('Options', () => {
     const options = new Options('localhost')
 
     options.setCustomWS(WebSocket)
-    expect(options.customWS()).to.be.eq(WebSocket)
+    expect(options.customWS).to.be.eq(WebSocket)
   })
 
   it('url/0', () => {
     const options = new Options('localhost.localdomain')
 
-    expect(options.url()).to.equal('wss://localhost.localdomain/ws')
+    expect(options.url).to.equal('wss://localhost.localdomain/ws')
   })
 
   it('url/0 with protocol', () => {
     const options = new Options('ws://localhost.localdomain')
 
-    expect(options.url()).to.equal('ws://localhost.localdomain')
+    expect(options.url).to.equal('ws://localhost.localdomain')
   })
 
   it('url/0 with protocol case two', () => {
     const options = new Options('wss://localhost.localdomain/ws')
 
-    expect(options.url()).to.equal('wss://localhost.localdomain/ws')
+    expect(options.url).to.equal('wss://localhost.localdomain/ws')
   })
 
   it('make/0', () => {