@xelis/sdk 0.10.0 → 0.10.2

package/dist/cjs/daemon/rpc.js

@@ -17,7 +17,7 @@ var __extends = (this && this.__extends) || (function () {
 exports.__esModule = true;
 exports.RPC = void 0;
 var types_1 = require("./types");
-var rpc_1 = require("../lib/rpc");
+var http_1 = require("../rpc/http");
 var RPC = /** @class */ (function (_super) {
     __extends(RPC, _super);
     function RPC() {
@@ -219,6 +219,6 @@ var RPC = /** @class */ (function (_super) {
         return this.request(types_1.RPCMethod.SubmitBlock, params);
     };
     return RPC;
-}(rpc_1.RPC));
+}(http_1.HttpRPC));
 exports.RPC = RPC;
 exports["default"] = RPC;

package/dist/cjs/daemon/websocket.js

@@ -17,7 +17,7 @@ var __extends = (this && this.__extends) || (function () {
 exports.__esModule = true;
 exports.WS = exports.DaemonMethods = void 0;
 var types_1 = require("./types");
-var websocket_1 = require("../lib/websocket");
+var websocket_1 = require("../rpc/websocket");
 var DaemonMethods = /** @class */ (function () {
     function DaemonMethods(ws, prefix) {
         if (prefix === void 0) { prefix = ""; }
@@ -285,6 +285,6 @@ var WS = /** @class */ (function (_super) {
         return _this;
     }
     return WS;
-}(websocket_1.WS));
+}(websocket_1.WSRPC));
 exports.WS = WS;
 exports["default"] = WS;

package/dist/cjs/{lib/rpc.js → rpc/http.js}

@@ -36,24 +36,29 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 exports.__esModule = true;
-exports.RPC = void 0;
+exports.HttpRPC = void 0;
 var parse_json_1 = require("./parse_json/parse_json");
-var RPC = /** @class */ (function () {
-    function RPC(endpoint) {
+var HttpRPC = /** @class */ (function () {
+    function HttpRPC(endpoint) {
         this.endpoint = endpoint;
         this.timeout = 3000;
         this.headers = new Headers();
         this.headers.set("Content-Type", "application/json");
     }
-    RPC.prototype.request = function (method, params) {
+    HttpRPC.prototype.batchRequest = function (requests) {
         return __awaiter(this, void 0, void 0, function () {
-            var controller_1, body, timeoutId, res, jsonString, data, err_1;
+            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();
-                        body = JSON.stringify({ id: 1, jsonrpc: '2.0', method: method, params: params });
+                        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);
@@ -68,6 +73,52 @@ var RPC = /** @class */ (function () {
                         clearTimeout(timeoutId);
                         if (!res.ok) return [3 /*break*/, 3];
                         return [4 /*yield*/, res.text()];
+                    case 2:
+                        jsonString = _a.sent();
+                        items_1 = [];
+                        data = (0, parse_json_1.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*/];
+                }
+            });
+        });
+    };
+    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 = (0, parse_json_1.parseJSON)(jsonString);
@@ -78,13 +129,13 @@ var RPC = /** @class */ (function () {
                     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)];
+                        err_2 = _a.sent();
+                        return [2 /*return*/, Promise.reject(err_2)];
                     case 6: return [2 /*return*/];
                 }
             });
         });
     };
-    return RPC;
+    return HttpRPC;
 }());
-exports.RPC = RPC;
+exports.HttpRPC = HttpRPC;

package/dist/cjs/{lib → rpc}/websocket.js

@@ -39,12 +39,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 exports.__esModule = true;
-exports.WS = void 0;
+exports.WSRPC = void 0;
 var isomorphic_ws_1 = __importDefault(require("isomorphic-ws"));
 var await_to_js_1 = require("await-to-js");
 var parse_json_1 = require("./parse_json/parse_json");
-var WS = /** @class */ (function () {
-    function WS(options) {
+var WSRPC = /** @class */ (function () {
+    function WSRPC(options) {
         this.connectionTries = 0;
         this.methodIdIncrement = 0;
         this.endpoint = "";
@@ -55,7 +55,7 @@ var WS = /** @class */ (function () {
         this.reconnectOnConnectionLoss = true;
         this.options = options;
     }
-    WS.prototype.connect = function (endpoint) {
+    WSRPC.prototype.connect = function (endpoint) {
         var _this = this;
         // force disconnect if already connected
         if (this.socket && this.socket.readyState === isomorphic_ws_1["default"].OPEN) {
@@ -83,7 +83,7 @@ var WS = /** @class */ (function () {
             });
         });
     };
-    WS.prototype.tryReconnect = function () {
+    WSRPC.prototype.tryReconnect = function () {
         var _this = this;
         this.connectionTries++;
         if (this.connectionTries > this.maxConnectionTries) {
@@ -97,12 +97,12 @@ var WS = /** @class */ (function () {
             _this.tryReconnect();
         });
     };
-    WS.prototype.close = function () {
+    WSRPC.prototype.close = function () {
         if (!this.socket)
             return;
         this.socket.close();
     };
-    WS.prototype.clearEvent = function (event) {
+    WSRPC.prototype.clearEvent = function (event) {
         var _this = this;
         var eventData = this.events.get(event);
         if (eventData) {
@@ -112,14 +112,14 @@ var WS = /** @class */ (function () {
             this.events["delete"](event);
         }
     };
-    WS.prototype.closeAllListens = function (event) {
+    WSRPC.prototype.closeAllListens = function (event) {
         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.call("unsubscribe", { notify: event }))];
+                        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)
@@ -131,31 +131,29 @@ var WS = /** @class */ (function () {
             });
         });
     };
-    WS.prototype.listenEvent = function (event, onData) {
+    WSRPC.prototype.listenEvent = function (event, onData) {
         return __awaiter(this, void 0, void 0, function () {
-            var onMessage, eventData, _a, err, res, closeListen;
+            var onMessage, eventData, idRefObject, _a, err, _, closeListen;
             var _this = this;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
                         onMessage = function (msgEvent) {
                             var eventData = _this.events.get(event);
-                            if (eventData) {
-                                if (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));
-                                            }
-                                            else {
-                                                onData(msgEvent, data.result, undefined);
-                                            }
+                            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));
+                                        }
+                                        else {
+                                            onData(msgEvent, data.result, undefined);
                                         }
                                     }
-                                    catch (_a) {
-                                        // can't parse json -- do nothing
-                                    }
+                                }
+                                catch (_a) {
+                                    // can't parse json -- do nothing
                                 }
                             }
                         };
@@ -168,14 +166,16 @@ var WS = /** @class */ (function () {
                         }
                         eventData.listeners.push(onMessage);
                         return [3 /*break*/, 3];
-                    case 1: return [4 /*yield*/, (0, await_to_js_1.to)(this.call("subscribe", { notify: event }))];
+                    case 1:
+                        idRefObject = {};
+                        return [4 /*yield*/, (0, await_to_js_1.to)(this.dataCall("subscribe", { notify: event }, idRefObject))];
                     case 2:
-                        _a = _b.sent(), err = _a[0], res = _a[1];
+                        _a = _b.sent(), err = _a[0], _ = _a[1];
                         if (err) {
                             this.clearEvent(event);
                             return [2 /*return*/, Promise.reject(err)];
                         }
-                        this.events.set(event, { listeners: [onMessage], id: res.id });
+                        this.events.set(event, { listeners: [onMessage], id: idRefObject.id });
                         _b.label = 3;
                     case 3:
                         this.socket && this.socket.addEventListener("message", onMessage);
@@ -195,7 +195,7 @@ var WS = /** @class */ (function () {
                                         // 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) {
-                                                this.call("unsubscribe", { notify: event });
+                                                this.dataCall("unsubscribe", { notify: event });
                                                 this.events["delete"](event);
                                                 return [2 /*return*/];
                                             });
@@ -215,70 +215,109 @@ var WS = /** @class */ (function () {
             });
         });
     };
-    WS.prototype.call = function (method, params, overwriteData) {
+    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 requestMethod = _this.createRequestMethod(method, params);
-            // for XSWD we want to send the application data without request method wrapping
-            if (overwriteData) {
-                requestMethod.id = null;
-                requestMethod.data = overwriteData;
-            }
             var timeoutId = null;
             var onMessage = function (msgEvent) {
                 if (typeof msgEvent.data === "string") {
                     var data = (0, parse_json_1.parseJSON)(msgEvent.data);
-                    if (data.id === requestMethod.id) {
+                    var valid = false;
+                    if (Array.isArray(data) && data.length > 0 && data[0].id === id) {
+                        //@ts-ignore
+                        resolve(data);
+                        valid = true;
+                    }
+                    else if (data.id === id) {
+                        resolve(data);
+                        valid = true;
+                    }
+                    else if (data.id === null && id === 0) {
+                        // special case with xswd sending first call will return null id
+                        resolve(data);
+                        valid = true;
+                    }
+                    if (valid) {
                         clearTimeout(timeoutId);
                         _this.socket && _this.socket.removeEventListener("message", onMessage);
-                        if (data.error)
-                            return reject(new Error(data.error.message));
-                        else
-                            resolve(data);
                     }
                 }
             };
-            // make sure you listen before sending data
-            _this.socket && _this.socket.addEventListener("message", onMessage); // we don't use { once: true } option because of timeout feature
+            _this.socket.addEventListener("message", onMessage);
             if (_this.timeout > 0) {
                 timeoutId = setTimeout(function () {
                     _this.socket && _this.socket.removeEventListener("message", onMessage);
                     reject(new Error("timeout"));
                 }, _this.timeout);
             }
-            if (_this.socket && _this.socket.readyState === isomorphic_ws_1["default"].OPEN) {
-                _this.socket.send(requestMethod.data);
+            if (_this.socket.readyState === isomorphic_ws_1["default"].OPEN) {
+                _this.socket.send(body);
             }
         });
     };
-    WS.prototype.dataCall = function (method, params) {
+    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 _a, err, res;
+            var id, request, data, _a, err, res;
             return __generator(this, function (_b) {
                 switch (_b.label) {
-                    case 0: return [4 /*yield*/, (0, await_to_js_1.to)(this.call(method, params))];
+                    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*/, (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)];
+                        if (res.error) {
+                            return [2 /*return*/, reject(res.error.message)];
+                        }
                         return [2 /*return*/, resolve(res.result)];
                 }
             });
         }); });
     };
-    WS.prototype.createRequestMethod = function (method, params) {
-        var id = this.methodIdIncrement++;
-        var request = { id: id, jsonrpc: "2.0", method: method };
-        if (params)
-            request.params = params;
-        var data = JSON.stringify(request);
-        return { data: data, id: id };
-    };
-    return WS;
+    return WSRPC;
 }());
-exports.WS = WS;
+exports.WSRPC = WSRPC;

package/dist/cjs/wallet/rpc.js

@@ -18,7 +18,7 @@ exports.__esModule = true;
 exports.RPC = void 0;
 var js_base64_1 = require("js-base64");
 var types_1 = require("./types");
-var rpc_1 = require("../lib/rpc");
+var http_1 = require("../rpc/http");
 var RPC = /** @class */ (function (_super) {
     __extends(RPC, _super);
     function RPC(endpoint, username, password) {
@@ -143,6 +143,6 @@ var RPC = /** @class */ (function (_super) {
         return this.request(types_1.RPCMethod.QueryDB, params);
     };
     return RPC;
-}(rpc_1.RPC));
+}(http_1.HttpRPC));
 exports.RPC = RPC;
 exports["default"] = RPC;

package/dist/cjs/wallet/websocket.js

@@ -16,7 +16,7 @@ var __extends = (this && this.__extends) || (function () {
 })();
 exports.__esModule = true;
 exports.WS = exports.WalletMethods = void 0;
-var websocket_1 = require("../lib/websocket");
+var websocket_1 = require("../rpc/websocket");
 var types_1 = require("./types");
 var WalletMethods = /** @class */ (function () {
     function WalletMethods(ws, prefix) {
@@ -177,6 +177,6 @@ var WS = /** @class */ (function (_super) {
         return _this;
     }
     return WS;
-}(websocket_1.WS));
+}(websocket_1.WSRPC));
 exports.WS = WS;
 exports["default"] = WS;

package/dist/cjs/xswd/websocket.js

@@ -16,7 +16,7 @@ var __extends = (this && this.__extends) || (function () {
 })();
 exports.__esModule = true;
 exports.WS = void 0;
-var websocket_1 = require("../lib/websocket");
+var websocket_1 = require("../rpc/websocket");
 var websocket_2 = require("../daemon/websocket");
 var websocket_3 = require("../wallet/websocket");
 var WS = /** @class */ (function (_super) {
@@ -30,9 +30,9 @@ var WS = /** @class */ (function (_super) {
     }
     WS.prototype.authorize = function (app) {
         var data = JSON.stringify(app);
-        return this.call("", {}, data);
+        return this.rawCall(0, data);
     };
     return WS;
-}(websocket_1.WS));
+}(websocket_1.WSRPC));
 exports.WS = WS;
 exports["default"] = WS;

package/dist/esm/daemon/rpc.js

@@ -14,7 +14,7 @@ var __extends = (this && this.__extends) || (function () {
     };
 })();
 import { RPCMethod } from './types.js';
-import { RPC as BaseRPC } from '../lib/rpc.js';
+import { HttpRPC } from '../rpc/http.js';
 var RPC = /** @class */ (function (_super) {
     __extends(RPC, _super);
     function RPC() {
@@ -216,6 +216,6 @@ var RPC = /** @class */ (function (_super) {
         return this.request(RPCMethod.SubmitBlock, params);
     };
     return RPC;
-}(BaseRPC));
+}(HttpRPC));
 export { RPC };
 export default RPC;

package/dist/esm/daemon/websocket.js

@@ -14,7 +14,7 @@ var __extends = (this && this.__extends) || (function () {
     };
 })();
 import { RPCMethod, RPCEvent } from './types.js';
-import { WS as BaseWS } from '../lib/websocket.js';
+import { WSRPC } from '../rpc/websocket.js';
 var DaemonMethods = /** @class */ (function () {
     function DaemonMethods(ws, prefix) {
         if (prefix === void 0) { prefix = ""; }
@@ -282,6 +282,6 @@ var WS = /** @class */ (function (_super) {
         return _this;
     }
     return WS;
-}(BaseWS));
+}(WSRPC));
 export { WS };
 export default WS;

package/dist/esm/{lib/rpc.js → rpc/http.js}

@@ -35,22 +35,27 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 import { parseJSON } from './parse_json/parse_json.js';
-var RPC = /** @class */ (function () {
-    function RPC(endpoint) {
+var HttpRPC = /** @class */ (function () {
+    function HttpRPC(endpoint) {
         this.endpoint = endpoint;
         this.timeout = 3000;
         this.headers = new Headers();
         this.headers.set("Content-Type", "application/json");
     }
-    RPC.prototype.request = function (method, params) {
+    HttpRPC.prototype.batchRequest = function (requests) {
         return __awaiter(this, void 0, void 0, function () {
-            var controller_1, body, timeoutId, res, jsonString, data, err_1;
+            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();
-                        body = JSON.stringify({ id: 1, jsonrpc: '2.0', method: method, params: params });
+                        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);
@@ -65,6 +70,52 @@ var RPC = /** @class */ (function () {
                         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*/];
+                }
+            });
+        });
+    };
+    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);
@@ -75,13 +126,13 @@ var RPC = /** @class */ (function () {
                     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)];
+                        err_2 = _a.sent();
+                        return [2 /*return*/, Promise.reject(err_2)];
                     case 6: return [2 /*return*/];
                 }
             });
         });
     };
-    return RPC;
+    return HttpRPC;
 }());
-export { RPC };
+export { HttpRPC };

package/dist/esm/{lib → rpc}/websocket.js

@@ -37,8 +37,8 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 import WebSocket from 'isomorphic-ws';
 import { to } from 'await-to-js';
 import { parseJSON } from './parse_json/parse_json.js';
-var WS = /** @class */ (function () {
-    function WS(options) {
+var WSRPC = /** @class */ (function () {
+    function WSRPC(options) {
         this.connectionTries = 0;
         this.methodIdIncrement = 0;
         this.endpoint = "";
@@ -49,7 +49,7 @@ var WS = /** @class */ (function () {
         this.reconnectOnConnectionLoss = true;
         this.options = options;
     }
-    WS.prototype.connect = function (endpoint) {
+    WSRPC.prototype.connect = function (endpoint) {
         var _this = this;
         // force disconnect if already connected
         if (this.socket && this.socket.readyState === WebSocket.OPEN) {
@@ -77,7 +77,7 @@ var WS = /** @class */ (function () {
             });
         });
     };
-    WS.prototype.tryReconnect = function () {
+    WSRPC.prototype.tryReconnect = function () {
         var _this = this;
         this.connectionTries++;
         if (this.connectionTries > this.maxConnectionTries) {
@@ -91,12 +91,12 @@ var WS = /** @class */ (function () {
             _this.tryReconnect();
         });
     };
-    WS.prototype.close = function () {
+    WSRPC.prototype.close = function () {
         if (!this.socket)
             return;
         this.socket.close();
     };
-    WS.prototype.clearEvent = function (event) {
+    WSRPC.prototype.clearEvent = function (event) {
         var _this = this;
         var eventData = this.events.get(event);
         if (eventData) {
@@ -106,14 +106,14 @@ var WS = /** @class */ (function () {
             this.events["delete"](event);
         }
     };
-    WS.prototype.closeAllListens = function (event) {
+    WSRPC.prototype.closeAllListens = function (event) {
         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*/, to(this.call("unsubscribe", { notify: event }))];
+                        return [4 /*yield*/, to(this.dataCall("unsubscribe", { notify: event }))];
                     case 1:
                         _a = _b.sent(), err = _a[0], _ = _a[1];
                         if (err)
@@ -125,31 +125,29 @@ var WS = /** @class */ (function () {
             });
         });
     };
-    WS.prototype.listenEvent = function (event, onData) {
+    WSRPC.prototype.listenEvent = function (event, onData) {
         return __awaiter(this, void 0, void 0, function () {
-            var onMessage, eventData, _a, err, res, closeListen;
+            var onMessage, eventData, idRefObject, _a, err, _, closeListen;
             var _this = this;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
                         onMessage = function (msgEvent) {
                             var eventData = _this.events.get(event);
-                            if (eventData) {
-                                if (typeof msgEvent.data === "string") {
-                                    try {
-                                        var data = parseJSON(msgEvent.data);
-                                        if (data.id === eventData.id) {
-                                            if (data.error) {
-                                                onData(msgEvent, undefined, new Error(data.error.message));
-                                            }
-                                            else {
-                                                onData(msgEvent, data.result, undefined);
-                                            }
+                            if (eventData && typeof msgEvent.data === "string") {
+                                try {
+                                    var data = parseJSON(msgEvent.data);
+                                    if (data.id === eventData.id) {
+                                        if (data.error) {
+                                            onData(msgEvent, undefined, new Error(data.error.message));
+                                        }
+                                        else {
+                                            onData(msgEvent, data.result, undefined);
                                         }
                                     }
-                                    catch (_a) {
-                                        // can't parse json -- do nothing
-                                    }
+                                }
+                                catch (_a) {
+                                    // can't parse json -- do nothing
                                 }
                             }
                         };
@@ -162,14 +160,16 @@ var WS = /** @class */ (function () {
                         }
                         eventData.listeners.push(onMessage);
                         return [3 /*break*/, 3];
-                    case 1: return [4 /*yield*/, to(this.call("subscribe", { notify: event }))];
+                    case 1:
+                        idRefObject = {};
+                        return [4 /*yield*/, to(this.dataCall("subscribe", { notify: event }, idRefObject))];
                     case 2:
-                        _a = _b.sent(), err = _a[0], res = _a[1];
+                        _a = _b.sent(), err = _a[0], _ = _a[1];
                         if (err) {
                             this.clearEvent(event);
                             return [2 /*return*/, Promise.reject(err)];
                         }
-                        this.events.set(event, { listeners: [onMessage], id: res.id });
+                        this.events.set(event, { listeners: [onMessage], id: idRefObject.id });
                         _b.label = 3;
                     case 3:
                         this.socket && this.socket.addEventListener("message", onMessage);
@@ -189,7 +189,7 @@ var WS = /** @class */ (function () {
                                         // 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) {
-                                                this.call("unsubscribe", { notify: event });
+                                                this.dataCall("unsubscribe", { notify: event });
                                                 this.events["delete"](event);
                                                 return [2 /*return*/];
                                             });
@@ -209,70 +209,109 @@ var WS = /** @class */ (function () {
             });
         });
     };
-    WS.prototype.call = function (method, params, overwriteData) {
+    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)];
+                }
+            });
+        }); });
+    };
+    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 !== WebSocket.OPEN)
                 return reject(new Error("Can't send msg. Socket is not opened."));
-            var requestMethod = _this.createRequestMethod(method, params);
-            // for XSWD we want to send the application data without request method wrapping
-            if (overwriteData) {
-                requestMethod.id = null;
-                requestMethod.data = overwriteData;
-            }
             var timeoutId = null;
             var onMessage = function (msgEvent) {
                 if (typeof msgEvent.data === "string") {
                     var data = parseJSON(msgEvent.data);
-                    if (data.id === requestMethod.id) {
+                    var valid = false;
+                    if (Array.isArray(data) && data.length > 0 && data[0].id === id) {
+                        //@ts-ignore
+                        resolve(data);
+                        valid = true;
+                    }
+                    else if (data.id === id) {
+                        resolve(data);
+                        valid = true;
+                    }
+                    else if (data.id === null && id === 0) {
+                        // special case with xswd sending first call will return null id
+                        resolve(data);
+                        valid = true;
+                    }
+                    if (valid) {
                         clearTimeout(timeoutId);
                         _this.socket && _this.socket.removeEventListener("message", onMessage);
-                        if (data.error)
-                            return reject(new Error(data.error.message));
-                        else
-                            resolve(data);
                     }
                 }
             };
-            // make sure you listen before sending data
-            _this.socket && _this.socket.addEventListener("message", onMessage); // we don't use { once: true } option because of timeout feature
+            _this.socket.addEventListener("message", onMessage);
             if (_this.timeout > 0) {
                 timeoutId = setTimeout(function () {
                     _this.socket && _this.socket.removeEventListener("message", onMessage);
                     reject(new Error("timeout"));
                 }, _this.timeout);
             }
-            if (_this.socket && _this.socket.readyState === WebSocket.OPEN) {
-                _this.socket.send(requestMethod.data);
+            if (_this.socket.readyState === WebSocket.OPEN) {
+                _this.socket.send(body);
             }
         });
     };
-    WS.prototype.dataCall = function (method, params) {
+    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 _a, err, res;
+            var id, request, data, _a, err, res;
             return __generator(this, function (_b) {
                 switch (_b.label) {
-                    case 0: return [4 /*yield*/, to(this.call(method, params))];
+                    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)];
                 }
             });
         }); });
     };
-    WS.prototype.createRequestMethod = function (method, params) {
-        var id = this.methodIdIncrement++;
-        var request = { id: id, jsonrpc: "2.0", method: method };
-        if (params)
-            request.params = params;
-        var data = JSON.stringify(request);
-        return { data: data, id: id };
-    };
-    return WS;
+    return WSRPC;
 }());
-export { WS };
+export { WSRPC };

package/dist/esm/wallet/rpc.js

@@ -15,7 +15,7 @@ var __extends = (this && this.__extends) || (function () {
 })();
 import { Base64 } from 'js-base64';
 import { RPCMethod } from './types.js';
-import { RPC as BaseRPC } from '../lib/rpc.js';
+import { HttpRPC } from '../rpc/http.js';
 var RPC = /** @class */ (function (_super) {
     __extends(RPC, _super);
     function RPC(endpoint, username, password) {
@@ -140,6 +140,6 @@ var RPC = /** @class */ (function (_super) {
         return this.request(RPCMethod.QueryDB, params);
     };
     return RPC;
-}(BaseRPC));
+}(HttpRPC));
 export { RPC };
 export default RPC;

package/dist/esm/wallet/websocket.js

@@ -13,7 +13,7 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
-import { WS as BaseWS } from '../lib/websocket.js';
+import { WSRPC } from '../rpc/websocket.js';
 import { RPCMethod, RPCEvent } from './types.js';
 var WalletMethods = /** @class */ (function () {
     function WalletMethods(ws, prefix) {
@@ -174,6 +174,6 @@ var WS = /** @class */ (function (_super) {
         return _this;
     }
     return WS;
-}(BaseWS));
+}(WSRPC));
 export { WS };
 export default WS;

package/dist/esm/xswd/websocket.js

@@ -13,7 +13,7 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
-import { WS as BaseWS } from '../lib/websocket.js';
+import { WSRPC } from '../rpc/websocket.js';
 import { DaemonMethods } from '../daemon/websocket.js';
 import { WalletMethods } from '../wallet/websocket.js';
 var WS = /** @class */ (function (_super) {
@@ -27,9 +27,9 @@ var WS = /** @class */ (function (_super) {
     }
     WS.prototype.authorize = function (app) {
         var data = JSON.stringify(app);
-        return this.call("", {}, data);
+        return this.rawCall(0, data);
     };
     return WS;
-}(BaseWS));
+}(WSRPC));
 export { WS };
 export default WS;

package/dist/types/daemon/rpc.d.ts

@@ -1,6 +1,6 @@
 import * as types from './types';
-import { RPC as BaseRPC } from '../lib/rpc';
-export declare class RPC extends BaseRPC {
+import { HttpRPC } from '../rpc/http';
+export declare class RPC extends HttpRPC {
     getVersion(): Promise<string>;
     getHeight(): Promise<number>;
     getTopoheight(): Promise<number>;

package/dist/types/daemon/websocket.d.ts

@@ -1,10 +1,10 @@
 import { MessageEvent } from 'ws';
 import * as types from './types';
-import { WS as BaseWS } from '../lib/websocket';
+import { WSRPC } from '../rpc/websocket';
 export declare class DaemonMethods {
-    ws: BaseWS;
+    ws: WSRPC;
     prefix: string;
-    constructor(ws: BaseWS, prefix?: string);
+    constructor(ws: WSRPC, prefix?: string);
     dataCall<T>(method: string, params?: any): Promise<T>;
     onNewBlock(onData: (msgEvent: MessageEvent, data?: types.Block & types.RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
     onBlockOrdered(onData: (msgEvent: MessageEvent, data?: types.BlockOrdered & types.RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
@@ -89,7 +89,7 @@ export declare class DaemonMethods {
     getMinerWork(params: types.GetMinerWorkParams): Promise<types.GetMinerWorkResult>;
     submitBlock(params: types.SubmitBlockParams): Promise<boolean>;
 }
-export declare class WS extends BaseWS {
+export declare class WS extends WSRPC {
     methods: DaemonMethods;
     constructor();
 }

package/dist/types/{lib/rpc.d.ts → rpc/http.d.ts}

@@ -1,7 +1,9 @@
-export declare class RPC {
+import { RPCRequest } from './types';
+export declare class HttpRPC {
     endpoint: string;
     timeout: number;
     headers: Headers;
     constructor(endpoint: string);
+    batchRequest(requests: RPCRequest[]): Promise<any | Error[]>;
     request<T>(method: string, params?: any): Promise<T>;
 }

package/dist/types/{lib → rpc}/websocket.d.ts

@@ -2,12 +2,15 @@
 import { ClientOptions, MessageEvent } from 'ws';
 import WebSocket from 'isomorphic-ws';
 import { ClientRequestArgs } from 'http';
-import { RPCResponse } from './types';
+import { RPCRequest } from './types';
 export type EventWithParams = {
     [event: string]: {};
 };
 export type EventKey = string | EventWithParams;
-export declare class WS {
+export type IdRefObj = {
+    id?: number;
+};
+export declare class WSRPC {
     endpoint: string;
     socket?: WebSocket;
     timeout: number;
@@ -25,10 +28,7 @@ export declare class WS {
     private clearEvent;
     closeAllListens(event: EventKey): Promise<void>;
     listenEvent<T>(event: EventKey, onData: (msgEvent: MessageEvent, data?: T, err?: Error) => void): Promise<() => Promise<void>>;
-    call<T>(method: string, params?: any, overwriteData?: string): Promise<RPCResponse<T>>;
-    dataCall<T>(method: string, params?: any): Promise<T>;
-    createRequestMethod(method: string, params?: any): {
-        data: string;
-        id: number | null;
-    };
+    batchCall(requests: RPCRequest[]): Promise<any[]>;
+    rawCall<T>(id: number, body: string): Promise<T>;
+    dataCall<T>(method: string, params?: any, idRefObj?: IdRefObj): Promise<T>;
 }

package/dist/types/wallet/rpc.d.ts

@@ -1,8 +1,8 @@
 import * as daemonTypes from '../daemon/types';
 import * as types from './types';
-import { RPC as BaseRPC } from '../lib/rpc';
+import { HttpRPC } from '../rpc/http';
 import { Element } from '../data/element';
-export declare class RPC extends BaseRPC {
+export declare class RPC extends HttpRPC {
     constructor(endpoint: string, username: string, password: string);
     getVersion(): Promise<string>;
     getNetwork(): Promise<string>;

package/dist/types/wallet/websocket.d.ts

@@ -1,13 +1,13 @@
-import { WS as BaseWS } from '../lib/websocket';
+import { WSRPC } from '../rpc/websocket';
 import { MessageEvent } from 'ws';
 import { RPCEventResult } from '../daemon/types';
 import * as daemonTypes from '../daemon/types';
 import * as types from './types';
 import { Element } from '../data/element';
 export declare class WalletMethods {
-    ws: BaseWS;
+    ws: WSRPC;
     prefix: string;
-    constructor(ws: BaseWS, prefix?: string);
+    constructor(ws: WSRPC, prefix?: string);
     dataCall<T>(method: string, params?: any): Promise<T>;
     onNewTopoheight(onData: (msgEvent: MessageEvent, data?: types.NewTopoheightResult & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
     onNewAsset(onData: (msgEvent: MessageEvent, data?: daemonTypes.AssetWithData & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
@@ -58,7 +58,7 @@ export declare class WalletMethods {
     hasKey(params: types.HasKeyParams): Promise<boolean>;
     queryDB(params: types.QueryDBParams): Promise<types.QueryResult>;
 }
-export declare class WS extends BaseWS {
+export declare class WS extends WSRPC {
     methods: WalletMethods;
     constructor(username: string, password: string);
 }

package/dist/types/xswd/websocket.d.ts

@@ -1,11 +1,11 @@
-import { WS as BaseWS } from '../lib/websocket';
+import { WSRPC } from '../rpc/websocket';
 import { ApplicationData } from '../wallet/types';
 import { DaemonMethods } from '../daemon/websocket';
 import { WalletMethods } from '../wallet/websocket';
-export declare class WS extends BaseWS {
+export declare class WS extends WSRPC {
     daemon: DaemonMethods;
     wallet: WalletMethods;
     constructor();
-    authorize(app: ApplicationData): Promise<import("../lib/types").RPCResponse<unknown>>;
+    authorize(app: ApplicationData): Promise<unknown>;
 }
 export default WS;

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.10.0",
+  "version": "0.10.2",
   "name": "@xelis/sdk",
   "description": "Xelis software development kit for JS",
   "exports": {