@gnolang/tm2-js-client 1.0.0

package/bin/provider/websocket/ws.d.ts

@@ -0,0 +1,55 @@
+/// <reference types="node" />
+import { Provider } from '../provider';
+import { BlockInfo, BlockResult, ConsensusParams, NetworkInfo, RPCRequest, RPCResponse, Status } from '../types';
+import { Tx } from '../../proto';
+/**
+ * Provider based on WS JSON-RPC HTTP requests
+ */
+export declare class WSProvider implements Provider {
+    protected ws: WebSocket;
+    protected readonly requestMap: Map<number | string, {
+        resolve: (response: RPCResponse<any>) => void;
+        reject: (reason: Error) => void;
+        timeout: NodeJS.Timeout;
+    }>;
+    protected requestTimeout: number;
+    /**
+     * Creates a new instance of the {@link WSProvider}
+     * @param {string} baseURL the WS URL of the node
+     * @param {number} requestTimeout the timeout for the WS request (in MS)
+     */
+    constructor(baseURL: string, requestTimeout?: number);
+    /**
+     * Closes the WS connection. Required when done working
+     * with the WS provider
+     */
+    closeConnection(): void;
+    /**
+     * Sends a request to the WS connection, and resolves
+     * upon receiving the response
+     * @param {RPCRequest} request the RPC request
+     */
+    sendRequest<Result>(request: RPCRequest): Promise<RPCResponse<Result>>;
+    /**
+     * Parses the result from the response
+     * @param {RPCResponse<Result>} response the response to be parsed
+     */
+    parseResponse<Result>(response: RPCResponse<Result>): Result;
+    /**
+     * Waits for the WS connection to be established
+     */
+    waitForOpenConnection: () => Promise<null>;
+    estimateGas(tx: Tx): Promise<number>;
+    getBalance(address: string, denomination?: string, height?: number): Promise<number>;
+    getBlock(height: number): Promise<BlockInfo>;
+    getBlockResult(height: number): Promise<BlockResult>;
+    getBlockNumber(): Promise<number>;
+    getConsensusParams(height: number): Promise<ConsensusParams>;
+    getGasPrice(): Promise<number>;
+    getNetwork(): Promise<NetworkInfo>;
+    getAccountSequence(address: string, height?: number): Promise<number>;
+    getAccountNumber(address: string, height?: number): Promise<number>;
+    getStatus(): Promise<Status>;
+    sendTransaction(tx: string): Promise<string>;
+    waitForTransaction(hash: string, fromHeight?: number, timeout?: number): Promise<Tx>;
+}

package/bin/provider/websocket/ws.js

@@ -0,0 +1,303 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WSProvider = void 0;
+var utility_1 = require("../utility");
+var endpoints_1 = require("../endpoints");
+/**
+ * Provider based on WS JSON-RPC HTTP requests
+ */
+var WSProvider = /** @class */ (function () {
+    /**
+     * Creates a new instance of the {@link WSProvider}
+     * @param {string} baseURL the WS URL of the node
+     * @param {number} requestTimeout the timeout for the WS request (in MS)
+     */
+    function WSProvider(baseURL, requestTimeout) {
+        var _this = this;
+        this.requestMap = new Map(); // callback method map for the individual endpoints
+        this.requestTimeout = 15000; // 15s
+        /**
+         * Waits for the WS connection to be established
+         */
+        this.waitForOpenConnection = function () {
+            return new Promise(function (resolve, reject) {
+                var maxNumberOfAttempts = 10;
+                var intervalTime = 200; //ms
+                var currentAttempt = 0;
+                var interval = setInterval(function () {
+                    if (_this.ws.readyState === WebSocket.OPEN) {
+                        clearInterval(interval);
+                        resolve(null);
+                    }
+                    currentAttempt++;
+                    if (currentAttempt > maxNumberOfAttempts - 1) {
+                        clearInterval(interval);
+                        reject(new Error('Maximum number of attempts exceeded'));
+                    }
+                }, intervalTime);
+            });
+        };
+        this.ws = new WebSocket(baseURL);
+        this.ws.addEventListener('message', function (event) {
+            var response = JSON.parse(event.data);
+            var request = _this.requestMap.get(response.id);
+            if (request) {
+                _this.requestMap.delete(response.id);
+                clearTimeout(request.timeout);
+                request.resolve(response);
+            }
+            // Set the default timeout
+            _this.requestTimeout = requestTimeout ? requestTimeout : 15000;
+        });
+    }
+    /**
+     * Closes the WS connection. Required when done working
+     * with the WS provider
+     */
+    WSProvider.prototype.closeConnection = function () {
+        this.ws.close();
+    };
+    /**
+     * Sends a request to the WS connection, and resolves
+     * upon receiving the response
+     * @param {RPCRequest} request the RPC request
+     */
+    WSProvider.prototype.sendRequest = function (request) {
+        return __awaiter(this, void 0, void 0, function () {
+            var promise;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(this.ws.readyState != WebSocket.OPEN)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.waitForOpenConnection()];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        promise = new Promise(function (resolve, reject) {
+                            var timeout = setTimeout(function () {
+                                _this.requestMap.delete(request.id);
+                                reject(new Error('Request timed out'));
+                            }, _this.requestTimeout);
+                            _this.requestMap.set(request.id, { resolve: resolve, reject: reject, timeout: timeout });
+                        });
+                        this.ws.send(JSON.stringify(request));
+                        return [2 /*return*/, promise];
+                }
+            });
+        });
+    };
+    /**
+     * Parses the result from the response
+     * @param {RPCResponse<Result>} response the response to be parsed
+     */
+    WSProvider.prototype.parseResponse = function (response) {
+        var _a;
+        if (!response) {
+            throw new Error('invalid response');
+        }
+        if (response.error) {
+            throw new Error((_a = response.error) === null || _a === void 0 ? void 0 : _a.message);
+        }
+        if (!response.result) {
+            throw new Error('invalid response returned');
+        }
+        return response.result;
+    };
+    WSProvider.prototype.estimateGas = function (tx) {
+        return Promise.reject('implement me');
+    };
+    WSProvider.prototype.getBalance = function (address, denomination, height) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, abciResponse;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.sendRequest((0, utility_1.newRequest)(endpoints_1.ABCIEndpoint.ABCI_QUERY, [
+                            "auth/accounts/".concat(address),
+                            '',
+                            '0',
+                            false,
+                        ]))];
+                    case 1:
+                        response = _a.sent();
+                        abciResponse = this.parseResponse(response);
+                        return [2 /*return*/, (0, utility_1.extractBalanceFromResponse)(abciResponse.response.ResponseBase.Data, denomination ? denomination : 'ugnot')];
+                }
+            });
+        });
+    };
+    WSProvider.prototype.getBlock = function (height) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.sendRequest((0, utility_1.newRequest)(endpoints_1.BlockEndpoint.BLOCK, [height.toString()]))];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, this.parseResponse(response)];
+                }
+            });
+        });
+    };
+    WSProvider.prototype.getBlockResult = function (height) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.sendRequest((0, utility_1.newRequest)(endpoints_1.BlockEndpoint.BLOCK_RESULTS, [height.toString()]))];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, this.parseResponse(response)];
+                }
+            });
+        });
+    };
+    WSProvider.prototype.getBlockNumber = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var status;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getStatus()];
+                    case 1:
+                        status = _a.sent();
+                        return [2 /*return*/, parseInt(status.sync_info.latest_block_height)];
+                }
+            });
+        });
+    };
+    WSProvider.prototype.getConsensusParams = function (height) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.sendRequest((0, utility_1.newRequest)(endpoints_1.ConsensusEndpoint.CONSENSUS_PARAMS, [height.toString()]))];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, this.parseResponse(response)];
+                }
+            });
+        });
+    };
+    WSProvider.prototype.getGasPrice = function () {
+        return Promise.reject('implement me');
+    };
+    WSProvider.prototype.getNetwork = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.sendRequest((0, utility_1.newRequest)(endpoints_1.ConsensusEndpoint.NET_INFO))];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, this.parseResponse(response)];
+                }
+            });
+        });
+    };
+    WSProvider.prototype.getAccountSequence = function (address, height) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, abciResponse;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.sendRequest((0, utility_1.newRequest)(endpoints_1.ABCIEndpoint.ABCI_QUERY, [
+                            "auth/accounts/".concat(address),
+                            '',
+                            '0',
+                            false,
+                        ]))];
+                    case 1:
+                        response = _a.sent();
+                        abciResponse = this.parseResponse(response);
+                        return [2 /*return*/, (0, utility_1.extractSequenceFromResponse)(abciResponse.response.ResponseBase.Data)];
+                }
+            });
+        });
+    };
+    WSProvider.prototype.getAccountNumber = function (address, height) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, abciResponse;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.sendRequest((0, utility_1.newRequest)(endpoints_1.ABCIEndpoint.ABCI_QUERY, [
+                            "auth/accounts/".concat(address),
+                            '',
+                            '0',
+                            false,
+                        ]))];
+                    case 1:
+                        response = _a.sent();
+                        abciResponse = this.parseResponse(response);
+                        return [2 /*return*/, (0, utility_1.extractAccountNumberFromResponse)(abciResponse.response.ResponseBase.Data)];
+                }
+            });
+        });
+    };
+    WSProvider.prototype.getStatus = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.sendRequest((0, utility_1.newRequest)(endpoints_1.CommonEndpoint.STATUS))];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, this.parseResponse(response)];
+                }
+            });
+        });
+    };
+    WSProvider.prototype.sendTransaction = function (tx) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.sendRequest((0, utility_1.newRequest)(endpoints_1.TransactionEndpoint.BROADCAST_TX_SYNC, [tx]))];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, this.parseResponse(response).hash];
+                }
+            });
+        });
+    };
+    WSProvider.prototype.waitForTransaction = function (hash, fromHeight, timeout) {
+        return (0, utility_1.waitForTransaction)(this, hash, fromHeight, timeout);
+    };
+    return WSProvider;
+}());
+exports.WSProvider = WSProvider;

package/bin/provider/websocket/ws.test.d.ts

@@ -0,0 +1 @@
+export {};