@tchain/tcabci-read-js-client 1.0.4 → 1.0.6

package/README.md

@@ -18,6 +18,9 @@ $ npm i @tchain/tcabci-read-js-client
 const tcAbciClient = require("@tchain/tcabci-read-js-client")
 
 const client = new tcAbciClient()
+// OR
+const client = new tcAbciClient(['https://read-node-01.transferchain.io',
+    'wss://read-node-01.transferchain.io/ws'])
 
 client.Start()
 

package/client.js

@@ -15,20 +15,27 @@ const {toJSON} = require("./util")
 const axios = require("axios")
 
 class TCAbciClient {
-    #subscribed = false
-    #subscribedAddresses = []
-    #connected = false
-    #version = "v0.1.0"
+    subscribed = false
+    subscribedAddresses = []
+    connected = false
+    version = "v0.1.0"
+    retrieverCount = 0
     errorCb = null
     listenCb = null
-    #ws = null
-    #httpClient = null
+    ws = null
+    httpClient = null
+    readNodeAddress = READ_NODE_ADDRESS
+    readNodeWSAddress = READ_NODE_WS_ADDRESS
 
-    constructor() {
-        this.#httpClient = axios.create({
-            baseURL: READ_NODE_ADDRESS,
+    constructor(readNodeAddresses = []) {
+        if (readNodeAddresses.length === 2) {
+            this.readNodeAddress = readNodeAddresses[0]
+            this.readNodeWSAddress = readNodeAddresses[1]
+        }
+        this.httpClient = axios.create({
+            baseURL: this.readNodeAddress,
             timeout: 10000,
-            headers: {'Client': `tcabaci-read-js-client${this.#version}`}
+            headers: {'Client': `tcabaci-read-js-client${this.version}`}
           })
     }
 
@@ -39,48 +46,21 @@ class TCAbciClient {
         this.listenCb = cb
     }
     Start() {
-        return new Promise((resolve, reject) => {
-            if (this.#getConnected()) {
-                reject(ALREADY_CONNECTED)
-            }
-            const wsClient = this.#wsClient()
-            this.#ws = new wsClient(READ_NODE_WS_ADDRESS)
-
-            this.#ws.onerror = (event) => {
-                this.#setConnected(false)
-                if (this.errorCb) {
-                    this.errorCb(event.error)
-                }
-                reject(event)
-            }
-            this.#ws.onopen = (event) => {
-                this.#setConnected(true)
-                resolve(event)
-            }
-            this.#ws.onmessage = (message) => {
-                if (message.data === "OK" && message.data.length < 10) {
-                    return { status: message.data }
-                }
-                if (this.listenCb) {
-                    this.listenCb(toJSON(message.data))
-                }
-            }
-
-        })
+        return this.connect()
     }
     Stop() {
-        if (!this.#getConnected()) {
+        if (!this.getConnected()) {
             throw NOT_CONNECTED
         }
-        this.#ws.close()
-        this.#setConnected(false)
-        this.#setSubscribed(false)
+        this.ws.close()
+        this.setConnected(false)
+        this.setSubscribed(false)
     }
     Subscribe(addresses) {
         if (!Array.isArray(addresses)) {
             throw INVALID_ARGUMENTS
         }
-        if (!this.#getConnected()) {
+        if (!this.getConnected()) {
             throw NOT_CONNECTED
         }
         let addrs = []
@@ -88,37 +68,37 @@ class TCAbciClient {
             throw ADDRESSES_IS_EMPTY
         }
         addrs = addresses
-        if (this.#getSubscribeAddresses().length > 0) {
+        if (this.getSubscribeAddresses().length > 0) {
             let newAddress = []
             for (let i = 0; i < addresses.length; i++) {
-                if (this.#getSubscribeAddresses().indexOf(addresses[i]) === -1 ){
+                if (this.getSubscribeAddresses().indexOf(addresses[i]) === -1 ){
                     newAddress.push(addresses[i])
                 }
             }
             addrs = newAddress
         }
         const message = new Message(true, MESSAGE_TYPE.SUBSCRIBE, addrs)
-        this.#ws.send(message.ToJSONString())
-        this.#setSubscribeAddresses(addrs, true)
-        this.#setSubscribed(true)
+        this.ws.send(message.ToJSONString())
+        this.setSubscribeAddresses(addrs, true)
+        this.setSubscribed(true)
     }
     Unsubscribe() {
-        if (!this.#getSubscribed()) {
+        if (!this.getSubscribed()) {
             throw NOT_SUBSCRIBED
         }
-        this.#ws.send(new Message(true, MESSAGE_TYPE.UNSUBSCRIBE, this.#getSubscribeAddresses()).ToJSONString())
-        this.#setSubscribed(false)
-        this.#setSubscribeAddresses([])
+        this.ws.send(new Message(true, MESSAGE_TYPE.UNSUBSCRIBE, this.getSubscribeAddresses()).ToJSONString())
+        this.setSubscribed(false)
+        this.setSubscribeAddresses([])
     }
     LastBlock() {
-        return this.#httpClient.get("/v1/blocks?limit=1&offset=0")
+        return this.httpClient.get("/v1/blocks?limit=1&offset=0")
             .then(res => { return { blocks: res.data.data, total_count: res.data.total_count } } )
             .catch(e => {
                 throw BLOCK_NOT_FOUND
             })
     }
     TxSearch({heightOperator, height, recipientAddrs, senderAddrs, hashes, typ, limit, offset, orderField, orderBy}) {
-        return this.#httpClient.post(
+        return this.httpClient.post(
                 "/v1/tx_search/p",
                 {
                     height: `${heightOperator} ${height}`,
@@ -143,8 +123,8 @@ class TCAbciClient {
     }
     Status() {
         return {
-            connected: this.#connected,
-            subscribed: this.#subscribed,
+            connected: this.connected,
+            subscribed: this.subscribed,
         }
     }
     Broadcast({id, version, type, data, sender_addr, recipient_addr, sign, fee}) {
@@ -152,7 +132,7 @@ class TCAbciClient {
             throw TRANSACTION_TYPE_NOT_VALID
         }
 
-        return this.#httpClient.post(
+        return this.httpClient.post(
             "/v1/broadcast",
             {
                 id,
@@ -168,34 +148,80 @@ class TCAbciClient {
             .catch(e => { throw TRANSACTION_NOT_BROADCAST })
     }
 
-    #wsClient() {
+    Disconnect(code = 1000) {
+        if (this.getConnected()) {
+            this.ws.close(code)
+        }
+    }
+
+    connect() {
+        return new Promise((resolve, reject) => {
+            if (this.getConnected()) {
+                reject(ALREADY_CONNECTED)
+            }
+            const wsClient = this.wsClient()
+            this.ws = new wsClient(this.readNodeWSAddress)
+
+            this.ws.onerror = (event) => {
+                this.setConnected(false)
+                if (this.errorCb) {
+                    this.errorCb(event.error)
+                }
+                reject(event)
+            }
+            this.ws.onopen = (event) => {
+                this.setConnected(true)
+                this.retrieverCount = 0
+                resolve(event)
+            }
+            this.ws.onmessage = (message) => {
+                if (message.data === "OK" && message.data.length < 10) {
+                    return { status: message.data }
+                }
+                if (this.listenCb) {
+                    this.listenCb(toJSON(message.data))
+                }
+            }
+            this.ws.onclose = (event) => {
+                this.setConnected(false)
+                if (event.code !== 1000 && this.retrieverCount <= 10) {
+                    this.retrieverCount++
+                    setTimeout(() => {
+                        this.connect().catch(() => {})
+                    }, 3000)
+                }
+            }
+        })
+    }
+
+    wsClient() {
         if (typeof window !== "undefined") {
             return window.WebSocket
         }
         const { WebSocket } = require("ws")
         return WebSocket
     }
-    #getConnected() {
-        return this.#connected
+    getConnected() {
+        return this.connected
     }
-    #setConnected(value) {
-        this.#connected = value
+    setConnected(value) {
+        this.connected = value
     }
-    #getSubscribed() {
-        return this.#subscribed
+    getSubscribed() {
+        return this.subscribed
     }
-    #setSubscribed(value) {
-        this.#subscribed = value
+    setSubscribed(value) {
+        this.subscribed = value
     }
-    #getSubscribeAddresses() {
-        return this.#subscribedAddresses
+    getSubscribeAddresses() {
+        return this.subscribedAddresses
     }
-    #setSubscribeAddresses(addresses, push = false) {
+    setSubscribeAddresses(addresses, push = false) {
         if (push) {
-            this.#subscribedAddresses.push(...addresses)
+            this.subscribedAddresses.push(...addresses)
             return
         }
-        this.#subscribedAddresses = addresses
+        this.subscribedAddresses = addresses
     }
 }
 

package/client_test.js

@@ -1,11 +1,25 @@
 const tcAbciClient = require("./client")
 const unitJS = require("unit.js")
-const {INVALID_ARGUMENTS, INVALID_URL, TRANSACTION_TYPE_NOT_VALID} = require("./errors")
-const { TX_TYPE } = require("./constants")
+const {INVALID_ARGUMENTS, INVALID_URL, TRANSACTION_TYPE_NOT_VALID, TRANSACTION_NOT_BROADCAST} = require("./errors")
+const { TX_TYPE, READ_NODE_ADDRESS, READ_NODE_WS_ADDRESS} = require("./constants")
 const {randomString} = require("./util")
 
 describe("TCAbciClient TESTS", () => {
 
+    it('should start with valid parameters and read node addresses',(done) => {
+        const client = new tcAbciClient([READ_NODE_ADDRESS, READ_NODE_WS_ADDRESS])
+        client.Start()
+            .then(() => {
+                const { connected, subscribed } = client.Status()
+                unitJS.assert.equal(connected, true)
+                unitJS.assert.equal(subscribed, false)
+                done()
+            })
+            .catch(err => {
+                done(err)
+            })
+    })
+
     it('should start with valid parameters',(done) => {
         const client = new tcAbciClient()
         client.Start()
@@ -20,6 +34,33 @@ describe("TCAbciClient TESTS", () => {
             })
     })
 
+    it('should reconnect with start and valid parameters',(done) => {
+        const client = new tcAbciClient()
+        client.Start()
+            .then(() => {
+                const { connected, subscribed } = client.Status()
+                unitJS.assert.equal(connected, true)
+                unitJS.assert.equal(subscribed, false)
+
+                client.Disconnect(1003)
+                setTimeout(() => {
+                    const { connected: c2, subscribed: b2} = client.Status()
+                    unitJS.assert.equal(c2, false)
+                    unitJS.assert.equal(b2, false)
+
+                    setTimeout(() => {
+                        const { connected, subscribed } = client.Status()
+                        unitJS.assert.equal(connected, true)
+                        unitJS.assert.equal(subscribed, false)
+                        done()
+                    }, 3100)
+                }, 1000)
+            })
+            .catch(err => {
+                done(err)
+            })
+    })
+
     it('should subscribe with valid parameters',(done) => {
         const client = new tcAbciClient()
         client.Start()
@@ -121,7 +162,8 @@ describe("TCAbciClient TESTS", () => {
                 done()
             })
             .catch(err => {
-                done(err)
+                unitJS.assert.equal(TRANSACTION_NOT_BROADCAST, err)
+                done()
             })
     })
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tchain/tcabci-read-js-client",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "TransferChain Fastest Read Network WebSocket Client",
   "main": "client.js",
   "type": "commonjs",