@xelis/sdk 0.10.12 → 0.11.0

package/dist/cjs/daemon/websocket.js

@@ -27,65 +27,11 @@ var DaemonMethods = /** @class */ (function () {
     DaemonMethods.prototype.dataCall = function (method, params) {
         return this.ws.dataCall(this.prefix + method, params);
     };
-    DaemonMethods.prototype.onNewBlock = function (onData) {
-        return this.ws.listenEvent(this.prefix + types_1.RPCEvent.NewBlock, onData);
+    DaemonMethods.prototype.closeListener = function (event, listener) {
+        this.ws.closeListener(event, listener);
     };
-    DaemonMethods.prototype.onBlockOrdered = function (onData) {
-        return this.ws.listenEvent(this.prefix + types_1.RPCEvent.BlockOrdered, onData);
-    };
-    DaemonMethods.prototype.onBlockOrphaned = function (onData) {
-        return this.ws.listenEvent(this.prefix + types_1.RPCEvent.BlockOrphaned, onData);
-    };
-    DaemonMethods.prototype.onStableHeightChanged = function (onData) {
-        return this.ws.listenEvent(this.prefix + types_1.RPCEvent.StableHeightChanged, onData);
-    };
-    DaemonMethods.prototype.onStableTopoHeightChanged = function (onData) {
-        return this.ws.listenEvent(this.prefix + types_1.RPCEvent.StableTopoHeightChanged, onData);
-    };
-    DaemonMethods.prototype.onTransactionOrphaned = function (onData) {
-        return this.ws.listenEvent(this.prefix + types_1.RPCEvent.TransactionOrphaned, onData);
-    };
-    DaemonMethods.prototype.onTransactionAddedInMempool = function (onData) {
-        return this.ws.listenEvent(this.prefix + types_1.RPCEvent.TransactionAddedInMempool, onData);
-    };
-    DaemonMethods.prototype.onTransactionExecuted = function (onData) {
-        return this.ws.listenEvent(this.prefix + types_1.RPCEvent.TransactionExecuted, onData);
-    };
-    DaemonMethods.prototype.onInvokeContract = function (contract, onData) {
-        var _a;
-        return this.ws.listenEvent((_a = {}, _a[this.prefix + types_1.RPCEvent.InvokeContract] = { contract: contract }, _a), onData);
-    };
-    DaemonMethods.prototype.onContractTransfer = function (address, onData) {
-        var _a;
-        return this.ws.listenEvent((_a = {}, _a[this.prefix + types_1.RPCEvent.ContractTransfer] = { address: address }, _a), onData);
-    };
-    DaemonMethods.prototype.onContractEvent = function (contract, id, onData) {
-        var _a;
-        return this.ws.listenEvent((_a = {}, _a[this.prefix + types_1.RPCEvent.ContractEvent] = { contract: contract, id: id }, _a), onData);
-    };
-    DaemonMethods.prototype.onDeployContract = function (onData) {
-        return this.ws.listenEvent(this.prefix + types_1.RPCEvent.DeployContract, onData);
-    };
-    DaemonMethods.prototype.onNewAsset = function (onData) {
-        return this.ws.listenEvent(this.prefix + types_1.RPCEvent.NewAsset, onData);
-    };
-    DaemonMethods.prototype.onPeerConnected = function (onData) {
-        return this.ws.listenEvent(this.prefix + types_1.RPCEvent.PeerConnected, onData);
-    };
-    DaemonMethods.prototype.onPeerDisconnected = function (onData) {
-        return this.ws.listenEvent(this.prefix + types_1.RPCEvent.PeerDisconnected, onData);
-    };
-    DaemonMethods.prototype.onPeerStateUpdated = function (onData) {
-        return this.ws.listenEvent(this.prefix + types_1.RPCEvent.PeerStateUpdated, onData);
-    };
-    DaemonMethods.prototype.onPeerPeerListUpdated = function (onData) {
-        return this.ws.listenEvent(this.prefix + types_1.RPCEvent.PeerPeerListUpdated, onData);
-    };
-    DaemonMethods.prototype.onPeerPeerDisconnected = function (onData) {
-        return this.ws.listenEvent(this.prefix + types_1.RPCEvent.PeerPeerDisconnected, onData);
-    };
-    DaemonMethods.prototype.onNewBlockTemplate = function (onData) {
-        return this.ws.listenEvent(this.prefix + types_1.RPCEvent.NewBlockTemplate, onData);
+    DaemonMethods.prototype.listen = function (event, listener) {
+        this.ws.listen(this.prefix + event, listener);
     };
     DaemonMethods.prototype.getVersion = function () {
         return this.dataCall(types_1.RPCMethod.GetVersion);
@@ -296,8 +242,8 @@ var DaemonMethods = /** @class */ (function () {
 exports.DaemonMethods = DaemonMethods;
 var WS = /** @class */ (function (_super) {
     __extends(WS, _super);
-    function WS() {
-        var _this = _super.call(this) || this;
+    function WS(endpoint) {
+        var _this = _super.call(this, endpoint) || this;
         _this.methods = new DaemonMethods(_this);
         return _this;
     }

package/dist/cjs/react/daemon.js

@@ -22,42 +22,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-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 };
-    }
-};
 var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
         if (ar || !(i in from)) {
@@ -73,49 +37,34 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 exports.__esModule = true;
 exports.useNodeSocket = exports.useNodeSocketSubscribe = exports.NodeSocketProvider = exports.INITIATING = void 0;
 var react_1 = __importStar(require("react"));
-var await_to_js_1 = require("await-to-js");
 var websocket_1 = __importDefault(require("../daemon/websocket"));
 exports.INITIATING = -1;
-var daemon = new websocket_1["default"]();
 var Context = (0, react_1.createContext)({
     err: undefined,
-    daemon: daemon,
+    daemon: undefined,
     readyState: exports.INITIATING
 });
 var NodeSocketProvider = function (props) {
     var children = props.children, endpoint = props.endpoint, timeout = props.timeout;
     var _a = (0, react_1.useState)(exports.INITIATING), readyState = _a[0], setReadyState = _a[1];
     var _b = (0, react_1.useState)(), err = _b[0], setErr = _b[1];
+    var _c = (0, react_1.useState)(), daemon = _c[0], setDaemon = _c[1];
     (0, react_1.useEffect)(function () {
-        var connect = function () { return __awaiter(void 0, void 0, void 0, function () {
-            var _a, err, _;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        setErr(undefined);
-                        return [4 /*yield*/, (0, await_to_js_1.to)(daemon.connect(endpoint))];
-                    case 1:
-                        _a = _b.sent(), err = _a[0], _ = _a[1];
-                        if (err)
-                            setErr(err);
-                        return [2 /*return*/];
-                }
-            });
-        }); };
-        connect();
+        var daemon = new websocket_1["default"](endpoint);
+        setDaemon(daemon);
+        return function () { return daemon.socket.close(); };
     }, [endpoint]);
     (0, react_1.useEffect)(function () {
         if (!timeout)
             return;
-        daemon.timeout = timeout;
+        if (daemon)
+            daemon.callTimeout = timeout;
     }, [timeout]);
     (0, react_1.useEffect)(function () {
-        if (!daemon.socket)
+        if (!daemon)
             return;
         setReadyState(daemon.socket.readyState);
         var onOpen = function () {
-            if (!daemon.socket)
-                return;
             setReadyState(daemon.socket.readyState);
             setErr(undefined);
         };
@@ -141,7 +90,7 @@ var NodeSocketProvider = function (props) {
             daemon.socket.removeEventListener("close", onClose);
             daemon.socket.removeEventListener("error", onError);
         };
-    }, [daemon.socket]);
+    }, [daemon]);
     return react_1["default"].createElement(Context.Provider, { value: { daemon: daemon, err: err, readyState: readyState } }, children);
 };
 exports.NodeSocketProvider = NodeSocketProvider;
@@ -149,24 +98,17 @@ var useNodeSocketSubscribe = function (_a, dependencies) {
     var event = _a.event, onLoad = _a.onLoad, onData = _a.onData;
     var nodeSocket = (0, exports.useNodeSocket)();
     (0, react_1.useEffect)(function () {
+        if (!nodeSocket.daemon)
+            return;
         if (nodeSocket.readyState !== WebSocket.OPEN)
             return;
         if (typeof onLoad === "function")
             onLoad();
-        var closeEvent;
-        var listen = function () { return __awaiter(void 0, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, nodeSocket.daemon.listenEvent(event, onData)];
-                    case 1:
-                        closeEvent = _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); };
-        listen();
+        nodeSocket.daemon.listen(event, onData);
         return function () {
-            closeEvent && closeEvent();
+            if (!nodeSocket.daemon)
+                return;
+            nodeSocket.daemon.closeListener(event, onData);
         };
     }, __spreadArray([nodeSocket], dependencies, true));
 };

package/dist/cjs/rpc/websocket.js

@@ -40,254 +40,121 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 exports.__esModule = true;
 exports.WSRPC = void 0;
-var isomorphic_ws_1 = __importDefault(require("isomorphic-ws"));
-var await_to_js_1 = require("await-to-js");
+var await_to_js_1 = __importDefault(require("await-to-js"));
 var parse_json_1 = require("./parse_json/parse_json");
+var isomorphic_ws_1 = __importDefault(require("isomorphic-ws"));
 var WSRPC = /** @class */ (function () {
-    function WSRPC(options) {
-        this.connectionTries = 0;
-        this.methodIdIncrement = 0;
-        this.endpoint = "";
-        this.timeout = 15000; // default to 15s
-        this.events = new Map();
-        this.unsubscribeSuspense = 1000;
-        this.maxConnectionTries = 3;
-        this.reconnectOnConnectionLoss = true;
-        this.options = options;
-    }
-    WSRPC.prototype.connect = function (endpoint) {
+    function WSRPC(endpoint, options) {
         var _this = this;
-        // force disconnect if already connected
-        if (this.socket && this.socket.readyState === isomorphic_ws_1["default"].OPEN) {
-            this.socket.close();
-        }
+        this.socket = new isomorphic_ws_1["default"](endpoint, options);
+        this.methodIdIncrement = 0;
+        this.callTimeout = 3000;
         this.events = new Map();
-        this.connectionTries = 0;
-        return new Promise(function (resolve, reject) {
-            _this.socket = new isomorphic_ws_1["default"](endpoint, _this.options);
-            _this.endpoint = endpoint;
-            _this.socket.addEventListener("open", function (event) {
-                resolve(event);
-            });
-            _this.socket.addEventListener("close", function (event) {
-                if (_this.reconnectOnConnectionLoss && !event.wasClean) {
-                    _this.tryReconnect();
-                    reject(new Error("Unhandled close. Reconnecting..."));
-                }
-                else {
-                    reject(event);
-                }
-            });
-            _this.socket.addEventListener("error", function (err) {
-                reject(err);
-            });
+        this.socket.addEventListener("close", function () {
+            _this.events = new Map();
         });
-    };
-    WSRPC.prototype.tryReconnect = function () {
-        var _this = this;
-        this.connectionTries++;
-        if (this.connectionTries > this.maxConnectionTries) {
-            return;
-        }
-        this.socket = new isomorphic_ws_1["default"](this.endpoint, this.options);
-        this.socket.addEventListener("open", function () {
-            _this.connectionTries = 0;
-        });
-        this.socket.addEventListener("close", function (event) {
-            _this.tryReconnect();
-        });
-    };
-    WSRPC.prototype.close = function () {
-        if (!this.socket)
-            return;
-        this.socket.close();
-    };
-    WSRPC.prototype.clearEvent = function (event) {
-        var _this = this;
-        var eventData = this.events.get(event);
-        if (eventData) {
-            eventData.listeners.forEach(function (listener) {
-                _this.socket && _this.socket.removeEventListener("message", listener);
-            });
-            this.events["delete"](event);
-        }
-    };
-    WSRPC.prototype.closeAllListens = function (event) {
+    }
+    WSRPC.prototype.closeListener = function (event, listener) {
         return __awaiter(this, void 0, void 0, function () {
-            var _a, err, _;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (!this.events.has(event)) return [3 /*break*/, 2];
-                        return [4 /*yield*/, (0, await_to_js_1.to)(this.dataCall("unsubscribe", { notify: event }))];
-                    case 1:
-                        _a = _b.sent(), err = _a[0], _ = _a[1];
-                        if (err)
-                            return [2 /*return*/, Promise.reject(err)];
-                        this.clearEvent(event);
-                        _b.label = 2;
-                    case 2: return [2 /*return*/, Promise.resolve()];
+            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.listenEvent = function (event, onData) {
+    WSRPC.prototype.listen = function (event, listener) {
         return __awaiter(this, void 0, void 0, function () {
-            var onMessage, eventData, idRefObject, _a, err, _, eventData_1, closeListen;
+            var eventData, idRefObject_1, onMessage;
             var _this = this;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        onMessage = function (msgEvent) {
-                            var eventData = _this.events.get(event);
-                            if (eventData && typeof msgEvent.data === "string") {
-                                try {
-                                    var data = (0, parse_json_1.parseJSON)(msgEvent.data);
-                                    if (data.id === eventData.id) {
-                                        if (data.error) {
-                                            onData(msgEvent, undefined, new Error(data.error.message));
+            return __generator(this, function (_a) {
+                eventData = this.events.get(event);
+                if (eventData) {
+                    eventData.listeners.push(listener);
+                    this.events.set(event, eventData);
+                }
+                else {
+                    idRefObject_1 = {};
+                    this.dataCall("subscribe", { notify: event }, idRefObject_1)["catch"](function (err) {
+                        listener(undefined, err);
+                    });
+                    onMessage = function (msgEvent) {
+                        var eventData = _this.events.get(event);
+                        if (eventData && typeof msgEvent.data === "string") {
+                            try {
+                                var data_1 = (0, parse_json_1.parseJSON)(msgEvent.data);
+                                if (data_1.id === idRefObject_1.id) {
+                                    eventData.listeners.forEach(function (listener) {
+                                        if (data_1.error) {
+                                            listener(undefined, new Error(data_1.error.message));
                                         }
                                         else {
-                                            onData(msgEvent, data.result, undefined);
+                                            listener(data_1.result, undefined);
                                         }
-                                    }
-                                }
-                                catch (_a) {
-                                    // can't parse json -- do nothing
+                                    });
                                 }
                             }
-                        };
-                        eventData = this.events.get(event);
-                        if (!eventData) return [3 /*break*/, 1];
-                        if (eventData.unsubscribeTimeoutId) {
-                            // clear timeout to unsubscribe 
-                            // because we got a new registered event and want to cancel the pending unsubscribe grace period
-                            clearTimeout(eventData.unsubscribeTimeoutId);
-                        }
-                        eventData.listeners.push(onMessage);
-                        return [3 /*break*/, 3];
-                    case 1:
-                        // important if multiple listenEvent are called without await at least we store listener before getting id
-                        // avoid trying to subscribe the same event multiple times
-                        this.events.set(event, { listeners: [onMessage] });
-                        idRefObject = {};
-                        return [4 /*yield*/, (0, await_to_js_1.to)(this.dataCall("subscribe", { notify: event }, idRefObject))];
-                    case 2:
-                        _a = _b.sent(), err = _a[0], _ = _a[1];
-                        if (err) {
-                            this.clearEvent(event);
-                            return [2 /*return*/, Promise.reject(err)];
-                        }
-                        eventData_1 = this.events.get(event);
-                        if (eventData_1)
-                            eventData_1.id = idRefObject.id;
-                        _b.label = 3;
-                    case 3:
-                        this.socket && this.socket.addEventListener("message", onMessage);
-                        closeListen = function () {
-                            var eventData = _this.events.get(event);
-                            if (eventData) {
-                                var listeners = eventData.listeners;
-                                for (var i = 0; i < listeners.length; i++) {
-                                    if (listeners[i] === onMessage) {
-                                        listeners.splice(i, 1);
-                                        break;
-                                    }
-                                }
-                                // no more listener so we unsubscribe from daemon websocket if socket still open
-                                if (listeners.length === 0) {
-                                    // we use a grace period to unsubscribe (mostly because of react useEffect and avoid unecessary subscribe)
-                                    eventData.unsubscribeTimeoutId = setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
-                                        return __generator(this, function (_a) {
-                                            if (this.socket && this.socket.readyState === isomorphic_ws_1["default"].OPEN) {
-                                                this.dataCall("unsubscribe", { notify: event });
-                                            }
-                                            this.events["delete"](event);
-                                            return [2 /*return*/];
-                                        });
-                                    }); }, _this.unsubscribeSuspense);
-                                }
+                            catch (_a) {
+                                // can't parse json -- do nothing
                             }
-                            _this.socket && _this.socket.removeEventListener("message", onMessage);
-                            return Promise.resolve();
-                        };
-                        return [2 /*return*/, Promise.resolve(closeListen)];
+                        }
+                    };
+                    this.socket.addEventListener("message", onMessage);
+                    this.events.set(event, { onMessage: onMessage, listeners: [listener] });
                 }
+                return [2 /*return*/];
             });
         });
     };
-    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*/, (0, await_to_js_1.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)];
-                }
-            });
-        }); });
-    };
     WSRPC.prototype.rawCall = function (id, body) {
         var _this = this;
         return new Promise(function (resolve, reject) {
-            if (!_this.socket)
-                return reject(new Error("Socket is not initialized."));
             if (_this.socket.readyState !== isomorphic_ws_1["default"].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_1 = (0, parse_json_1.parseJSON)(msgEvent.data);
+                    var data_2 = (0, parse_json_1.parseJSON)(msgEvent.data);
                     var evaluate_data = function () {
                         clearTimeout(timeoutId);
-                        _this.socket && _this.socket.removeEventListener("message", onMessage);
-                        if (data_1.error && data_1.error.message) {
-                            reject(new Error(data_1.error.message));
+                        _this.socket.removeEventListener("message", onMessage);
+                        if (data_2.error && data_2.error.message) {
+                            reject(new Error(data_2.error.message));
                             return;
                         }
-                        return resolve(data_1);
+                        return resolve(data_2);
                     };
                     // this is for batch call we match the id with first item id
-                    if (Array.isArray(data_1) && data_1.length > 0 && data_1[0].id === id) {
+                    if (Array.isArray(data_2) && data_2.length > 0 && data_2[0].id === id) {
                         return evaluate_data();
                     }
                     // the msg id is matching so we can evaluate the data
-                    if (data_1.id === id) {
+                    if (data_2.id === id) {
                         return evaluate_data();
                     }
                     // special XSWD case - sending first call will return null id
-                    if (data_1.id === null && id === 0) {
+                    if (data_2.id === null && id === 0) {
                         return evaluate_data();
                     }
                 }
             };
             _this.socket.addEventListener("message", onMessage);
-            if (_this.timeout > 0) {
+            if (_this.callTimeout > 0) {
                 timeoutId = setTimeout(function () {
                     _this.socket && _this.socket.removeEventListener("message", onMessage);
                     reject(new Error("timeout"));
-                }, _this.timeout);
+                }, _this.callTimeout);
             }
             if (_this.socket.readyState === isomorphic_ws_1["default"].OPEN) {
                 _this.socket.send(body);
@@ -308,7 +175,7 @@ var WSRPC = /** @class */ (function () {
                         if (params)
                             request.params = params;
                         data = JSON.stringify(request);
-                        return [4 /*yield*/, (0, await_to_js_1.to)(this.rawCall(id, data))];
+                        return [4 /*yield*/, (0, await_to_js_1["default"])(this.rawCall(id, data))];
                     case 1:
                         _a = _b.sent(), err = _a[0], res = _a[1];
                         if (err)
@@ -321,6 +188,38 @@ var WSRPC = /** @class */ (function () {
             });
         }); });
     };
+    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*/, (0, await_to_js_1["default"])(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)];
+                }
+            });
+        }); });
+    };
     return WSRPC;
 }());
 exports.WSRPC = WSRPC;

package/dist/cjs/wallet/websocket.js

@@ -27,29 +27,11 @@ var WalletMethods = /** @class */ (function () {
     WalletMethods.prototype.dataCall = function (method, params) {
         return this.ws.dataCall(this.prefix + method, params);
     };
-    WalletMethods.prototype.onNewTopoheight = function (onData) {
-        return this.ws.listenEvent(this.prefix + types_1.RPCEvent.NewTopoheight, onData);
+    WalletMethods.prototype.closeListener = function (event, listener) {
+        this.ws.closeListener(event, listener);
     };
-    WalletMethods.prototype.onNewAsset = function (onData) {
-        return this.ws.listenEvent(this.prefix + types_1.RPCEvent.NewAsset, onData);
-    };
-    WalletMethods.prototype.onNewTransaction = function (onData) {
-        return this.ws.listenEvent(this.prefix + types_1.RPCEvent.NewTransaction, onData);
-    };
-    WalletMethods.prototype.onBalanceChanged = function (onData) {
-        return this.ws.listenEvent(this.prefix + types_1.RPCEvent.BalanceChanged, onData);
-    };
-    WalletMethods.prototype.onRescan = function (onData) {
-        return this.ws.listenEvent(this.prefix + types_1.RPCEvent.Rescan, onData);
-    };
-    WalletMethods.prototype.onHistorySynced = function (onData) {
-        return this.ws.listenEvent(this.prefix + types_1.RPCEvent.HistorySynced, onData);
-    };
-    WalletMethods.prototype.onOnline = function (onData) {
-        return this.ws.listenEvent(this.prefix + types_1.RPCEvent.Online, onData);
-    };
-    WalletMethods.prototype.onOffline = function (onData) {
-        return this.ws.listenEvent(this.prefix + types_1.RPCEvent.Offline, onData);
+    WalletMethods.prototype.listen = function (event, listener) {
+        this.ws.listen(this.prefix + event, listener);
     };
     WalletMethods.prototype.getVersion = function () {
         return this.dataCall(types_1.RPCMethod.GetVersion);
@@ -177,8 +159,8 @@ var WalletMethods = /** @class */ (function () {
 exports.WalletMethods = WalletMethods;
 var WS = /** @class */ (function (_super) {
     __extends(WS, _super);
-    function WS(username, password) {
-        var _this = _super.call(this, { auth: "".concat(username, ":").concat(password) }) || this;
+    function WS(endpoint, username, password) {
+        var _this = _super.call(this, endpoint, { auth: "".concat(username, ":").concat(password) }) || this;
         _this.methods = new WalletMethods(_this);
         return _this;
     }