@xelis/sdk 0.11.15 → 0.11.17

package/dist/esm/rpc/http.js

@@ -1,138 +1,80 @@
-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 };
-    }
-};
 import { parseJSON } from './parse_json/parse_json.js';
-var HttpRPC = /** @class */ (function () {
-    function HttpRPC(endpoint) {
+export class HttpRPC {
+    constructor(endpoint) {
         this.endpoint = endpoint;
         this.timeout = 3000;
         this.headers = new Headers();
-        this.headers.set("Content-Type", "application/json");
+        this.headers.set(`Content-Type`, `application/json`);
     }
-    HttpRPC.prototype.batchRequest = function (requests) {
-        return __awaiter(this, void 0, void 0, function () {
-            var controller_1, id_1, body, timeoutId, res, jsonString, items_1, data, err_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 5, , 6]);
-                        controller_1 = new AbortController();
-                        id_1 = 0;
-                        requests.forEach(function (request) {
-                            request.id = ++id_1;
-                            request.jsonrpc = "2.0";
-                        });
-                        body = JSON.stringify(requests);
-                        timeoutId = setTimeout(function () {
-                            controller_1.abort();
-                        }, this.timeout);
-                        return [4 /*yield*/, fetch(this.endpoint, {
-                                headers: this.headers,
-                                method: "POST",
-                                body: body,
-                                signal: controller_1.signal
-                            })];
-                    case 1:
-                        res = _a.sent();
-                        clearTimeout(timeoutId);
-                        if (!res.ok) return [3 /*break*/, 3];
-                        return [4 /*yield*/, res.text()];
-                    case 2:
-                        jsonString = _a.sent();
-                        items_1 = [];
-                        data = parseJSON(jsonString);
-                        data.forEach(function (item) {
-                            if (item.error) {
-                                items_1.push(new Error(item.error.message));
-                            }
-                            else {
-                                items_1.push(item.result);
-                            }
-                        });
-                        return [2 /*return*/, Promise.resolve(items_1)];
-                    case 3: return [2 /*return*/, Promise.reject(new Error("".concat(res.status, " - ").concat(res.statusText)))];
-                    case 4: return [3 /*break*/, 6];
-                    case 5:
-                        err_1 = _a.sent();
-                        return [2 /*return*/, Promise.reject(err_1)];
-                    case 6: return [2 /*return*/];
-                }
+    async batchRequest(requests) {
+        try {
+            const controller = new AbortController();
+            let id = 0;
+            requests.forEach((request) => {
+                request.id = ++id;
+                request.jsonrpc = "2.0";
             });
-        });
-    };
-    HttpRPC.prototype.request = function (method, params) {
-        return __awaiter(this, void 0, void 0, function () {
-            var controller_2, body, timeoutId, res, jsonString, data, err_2;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 5, , 6]);
-                        controller_2 = new AbortController();
-                        body = JSON.stringify({ id: 1, jsonrpc: '2.0', method: method, params: params });
-                        timeoutId = setTimeout(function () {
-                            controller_2.abort();
-                        }, this.timeout);
-                        return [4 /*yield*/, fetch(this.endpoint, {
-                                headers: this.headers,
-                                method: "POST",
-                                body: body,
-                                signal: controller_2.signal
-                            })];
-                    case 1:
-                        res = _a.sent();
-                        clearTimeout(timeoutId);
-                        if (!res.ok) return [3 /*break*/, 3];
-                        return [4 /*yield*/, res.text()];
-                    case 2:
-                        jsonString = _a.sent();
-                        data = parseJSON(jsonString);
-                        if (data.error) {
-                            return [2 /*return*/, Promise.reject(new Error(data.error.message))];
-                        }
-                        return [2 /*return*/, Promise.resolve(data.result)];
-                    case 3: return [2 /*return*/, Promise.reject(new Error("".concat(res.status, " - ").concat(res.statusText)))];
-                    case 4: return [3 /*break*/, 6];
-                    case 5:
-                        err_2 = _a.sent();
-                        return [2 /*return*/, Promise.reject(err_2)];
-                    case 6: return [2 /*return*/];
-                }
+            const body = JSON.stringify(requests);
+            const timeoutId = setTimeout(() => {
+                controller.abort();
+            }, this.timeout);
+            const res = await fetch(this.endpoint, {
+                headers: this.headers,
+                method: `POST`,
+                body,
+                signal: controller.signal
+            });
+            clearTimeout(timeoutId);
+            if (res.ok) {
+                const jsonString = await res.text();
+                let items = [];
+                const data = parseJSON(jsonString);
+                data.forEach((item) => {
+                    if (item.error) {
+                        items.push(new Error(item.error.message));
+                    }
+                    else {
+                        items.push(item.result);
+                    }
+                });
+                return Promise.resolve(items);
+            }
+            else {
+                return Promise.reject(new Error(`${res.status} - ${res.statusText}`));
+            }
+        }
+        catch (err) {
+            return Promise.reject(err);
+        }
+    }
+    async request(method, params) {
+        try {
+            const controller = new AbortController();
+            const body = JSON.stringify({ id: 1, jsonrpc: '2.0', method: method, params });
+            const timeoutId = setTimeout(() => {
+                controller.abort();
+            }, this.timeout);
+            const res = await fetch(this.endpoint, {
+                headers: this.headers,
+                method: `POST`,
+                body,
+                signal: controller.signal
             });
-        });
-    };
-    return HttpRPC;
-}());
-export { HttpRPC };
+            clearTimeout(timeoutId);
+            if (res.ok) {
+                const jsonString = await res.text();
+                const data = parseJSON(jsonString);
+                if (data.error) {
+                    return Promise.reject(new Error(data.error.message));
+                }
+                return Promise.resolve(data.result);
+            }
+            else {
+                return Promise.reject(new Error(`${res.status} - ${res.statusText}`));
+            }
+        }
+        catch (err) {
+            return Promise.reject(err);
+        }
+    }
+}

package/dist/esm/rpc/parse_json/parse_json.js

@@ -3,6 +3,6 @@ import JSONbig from 'json-bigint';
 // for ex: the API returns the nonce as a number instead of a string and JSON.parse() is rounding the number because of overflow
 // instead we will return any BigInt as a string and avoid precision loss
 // NOTE: Previously was using lossless-json with isSafeNumber, but its too slow for big json data
-export var parseJSON = function (data) {
+export const parseJSON = (data) => {
     return JSONbig({ storeAsString: true }).parse(data);
 };

package/dist/esm/rpc/websocket.js

@@ -1,231 +1,160 @@
-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 };
-    }
-};
 import to from "await-to-js";
 import { parseJSON } from "./parse_json/parse_json.js";
 import WebSocket from 'isomorphic-ws';
-var WSRPC = /** @class */ (function () {
-    function WSRPC(endpoint, options) {
-        var _this = this;
+export class WSRPC {
+    constructor(endpoint, options) {
         this.socket = new WebSocket(endpoint, options);
         this.methodIdIncrement = 0;
         this.callTimeout = 3000;
         this.events = new Map();
-        this.socket.addEventListener("close", function () {
-            _this.events = new Map();
+        this.socket.addEventListener(`close`, () => {
+            this.events = new Map();
         });
     }
-    WSRPC.prototype.closeListener = function (event, listener) {
-        return __awaiter(this, void 0, void 0, function () {
-            var eventData;
-            return __generator(this, function (_a) {
-                eventData = this.events.get(event);
-                if (eventData) {
-                    if (eventData.listeners.length > 1) {
-                        eventData.listeners = eventData.listeners.filter(function (l) { return l !== listener; });
-                        this.events.set(event, eventData);
-                    }
-                    else {
-                        this.events["delete"](event);
-                        this.socket.removeEventListener("message", eventData.onMessage);
-                        this.dataCall("unsubscribe", { notify: event });
-                    }
-                }
-                return [2 /*return*/];
-            });
-        });
-    };
-    WSRPC.prototype.listen = function (event, listener) {
-        return __awaiter(this, void 0, void 0, function () {
-            var listenEvent, wait_for_open_1;
-            var _this = this;
-            return __generator(this, function (_a) {
-                listenEvent = function () {
-                    var eventData = _this.events.get(event);
-                    if (eventData) {
-                        eventData.listeners.push(listener);
-                        _this.events.set(event, eventData);
-                    }
-                    else {
-                        var idRefObject_1 = {};
-                        _this.dataCall("subscribe", { notify: event }, idRefObject_1);
-                        var onMessage = function (msgEvent) {
-                            var eventData = _this.events.get(event);
-                            if (eventData && typeof msgEvent.data === "string") {
-                                try {
-                                    var data_1 = parseJSON(msgEvent.data);
-                                    // event result will contain an event parameter with the event name defined
-                                    if (data_1.result["event"] === event && data_1.id === idRefObject_1.id) {
-                                        eventData.listeners.forEach(function (listener) {
-                                            if (data_1.error) {
-                                                listener(undefined, new Error(data_1.error.message));
-                                            }
-                                            else {
-                                                listener(data_1.result, undefined);
-                                            }
-                                        });
+    async closeListener(event, listener) {
+        const eventData = this.events.get(event);
+        if (eventData) {
+            if (eventData.listeners.length > 1) {
+                eventData.listeners = eventData.listeners.filter(l => l !== listener);
+                this.events.set(event, eventData);
+            }
+            else {
+                this.events.delete(event);
+                this.socket.removeEventListener(`message`, eventData.onMessage);
+                this.dataCall(`unsubscribe`, { notify: event });
+            }
+        }
+    }
+    async listen(event, listener) {
+        const listenEvent = () => {
+            const eventData = this.events.get(event);
+            if (eventData) {
+                eventData.listeners.push(listener);
+                this.events.set(event, eventData);
+            }
+            else {
+                let idRefObject = {};
+                this.dataCall(`subscribe`, { notify: event }, idRefObject);
+                const onMessage = (msgEvent) => {
+                    const eventData = this.events.get(event);
+                    if (eventData && typeof msgEvent.data === `string`) {
+                        try {
+                            const data = parseJSON(msgEvent.data);
+                            // event result will contain an event parameter with the event name defined
+                            if (data.result["event"] === event && data.id === idRefObject.id) {
+                                eventData.listeners.forEach((listener) => {
+                                    if (data.error) {
+                                        listener(undefined, new Error(data.error.message));
                                     }
-                                }
-                                catch (_a) {
-                                    // can't parse json -- do nothing
-                                }
+                                    else {
+                                        listener(data.result, undefined);
+                                    }
+                                });
                             }
-                        };
-                        _this.socket.addEventListener("message", onMessage);
-                        _this.events.set(event, { onMessage: onMessage, listeners: [listener] });
+                        }
+                        catch {
+                            // can't parse json -- do nothing
+                        }
                     }
                 };
-                // make sure connection is open or wait
-                if (this.socket.readyState === WebSocket.OPEN) {
-                    listenEvent();
-                }
-                else {
-                    wait_for_open_1 = function () {
-                        listenEvent();
-                        _this.socket.removeEventListener("open", wait_for_open_1);
-                    };
-                    this.socket.addEventListener("open", wait_for_open_1);
-                }
-                return [2 /*return*/];
-            });
-        });
-    };
-    WSRPC.prototype.rawCall = function (id, body) {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
-            if (_this.socket.readyState !== WebSocket.OPEN)
-                return reject(new Error("Can't send msg. Socket is not opened."));
-            var timeoutId = null;
-            var onMessage = function (msgEvent) {
-                if (typeof msgEvent.data === "string") {
-                    var data_2 = parseJSON(msgEvent.data);
-                    var evaluate_data = function () {
+                this.socket.addEventListener(`message`, onMessage);
+                this.events.set(event, { onMessage, listeners: [listener] });
+            }
+        };
+        // make sure connection is open or wait
+        if (this.socket.readyState === WebSocket.OPEN) {
+            listenEvent();
+        }
+        else {
+            const wait_for_open = () => {
+                listenEvent();
+                this.socket.removeEventListener(`open`, wait_for_open);
+            };
+            this.socket.addEventListener(`open`, wait_for_open);
+        }
+    }
+    rawCall(id, body) {
+        return new Promise((resolve, reject) => {
+            if (this.socket.readyState !== WebSocket.OPEN)
+                return reject(new Error(`Can't send msg. Socket is not opened.`));
+            let timeoutId = null;
+            const onMessage = (msgEvent) => {
+                if (typeof msgEvent.data === `string`) {
+                    const data = parseJSON(msgEvent.data);
+                    const evaluate_data = () => {
                         clearTimeout(timeoutId);
-                        _this.socket.removeEventListener("message", onMessage);
-                        if (data_2.error && data_2.error.message) {
-                            reject(new Error(data_2.error.message));
+                        this.socket.removeEventListener(`message`, onMessage);
+                        if (data.error && data.error.message) {
+                            reject(new Error(data.error.message));
                             return;
                         }
-                        return resolve(data_2);
+                        return resolve(data);
                     };
                     // this is for batch call we match the id with first item id
-                    if (Array.isArray(data_2) && data_2.length > 0 && data_2[0].id === id) {
+                    if (Array.isArray(data) && data.length > 0 && data[0].id === id) {
                         return evaluate_data();
                     }
                     // the msg id is matching so we can evaluate the data
-                    if (data_2.id === id) {
+                    if (data.id === id) {
                         return evaluate_data();
                     }
                     // special XSWD case - sending first call will return null id
-                    if (data_2.id === null && id === 0) {
+                    if (data.id === null && id === 0) {
                         return evaluate_data();
                     }
                 }
             };
-            _this.socket.addEventListener("message", onMessage);
-            if (_this.callTimeout > 0) {
-                timeoutId = setTimeout(function () {
-                    _this.socket && _this.socket.removeEventListener("message", onMessage);
-                    reject(new Error("timeout"));
-                }, _this.callTimeout);
+            this.socket.addEventListener(`message`, onMessage);
+            if (this.callTimeout > 0) {
+                timeoutId = setTimeout(() => {
+                    this.socket && this.socket.removeEventListener(`message`, onMessage);
+                    reject(new Error(`timeout`));
+                }, this.callTimeout);
             }
-            if (_this.socket.readyState === WebSocket.OPEN) {
-                _this.socket.send(body);
+            if (this.socket.readyState === WebSocket.OPEN) {
+                this.socket.send(body);
             }
         });
-    };
-    WSRPC.prototype.dataCall = function (method, params, idRefObj) {
-        var _this = this;
-        return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
-            var id, request, data, _a, err, res;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        id = this.methodIdIncrement++;
-                        if (idRefObj)
-                            idRefObj.id = id;
-                        request = { id: id, jsonrpc: "2.0", method: method };
-                        if (params)
-                            request.params = params;
-                        data = JSON.stringify(request);
-                        return [4 /*yield*/, to(this.rawCall(id, data))];
-                    case 1:
-                        _a = _b.sent(), err = _a[0], res = _a[1];
-                        if (err)
-                            return [2 /*return*/, reject(err)];
-                        if (res.error) {
-                            return [2 /*return*/, reject(res.error.message)];
-                        }
-                        return [2 /*return*/, resolve(res.result)];
-                }
+    }
+    dataCall(method, params, idRefObj) {
+        return new Promise(async (resolve, reject) => {
+            const id = this.methodIdIncrement++;
+            if (idRefObj)
+                idRefObj.id = id;
+            const request = { id, jsonrpc: `2.0`, method };
+            if (params)
+                request.params = params;
+            const data = JSON.stringify(request);
+            const [err, res] = await to(this.rawCall(id, data));
+            if (err)
+                return reject(err);
+            if (res.error) {
+                return reject(res.error.message);
+            }
+            return resolve(res.result);
+        });
+    }
+    batchCall(requests) {
+        return new Promise(async (resolve, reject) => {
+            let id = this.methodIdIncrement++;
+            requests.forEach((request) => {
+                request.id = id;
+                request.jsonrpc = "2.0";
             });
-        }); });
-    };
-    WSRPC.prototype.batchCall = function (requests) {
-        var _this = this;
-        return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
-            var id, data, _a, err, res, items;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        id = this.methodIdIncrement++;
-                        requests.forEach(function (request) {
-                            request.id = id;
-                            request.jsonrpc = "2.0";
-                        });
-                        data = JSON.stringify(requests);
-                        return [4 /*yield*/, to(this.rawCall(id, data))];
-                    case 1:
-                        _a = _b.sent(), err = _a[0], res = _a[1];
-                        if (err)
-                            return [2 /*return*/, reject(err)];
-                        items = [];
-                        res.forEach(function (v) {
-                            if (v.error) {
-                                items.push(new Error(v.error.message));
-                            }
-                            else {
-                                items.push(v.result);
-                            }
-                        });
-                        return [2 /*return*/, resolve(items)];
+            const data = JSON.stringify(requests);
+            const [err, res] = await to(this.rawCall(id, data));
+            if (err)
+                return reject(err);
+            let items = [];
+            res.forEach((v) => {
+                if (v.error) {
+                    items.push(new Error(v.error.message));
+                }
+                else {
+                    items.push(v.result);
                 }
             });
-        }); });
-    };
-    return WSRPC;
-}());
-export { WSRPC };
+            return resolve(items);
+        });
+    }
+}