@xelis/sdk 0.10.12 → 0.11.1

package/dist/esm/rpc/websocket.js

@@ -34,254 +34,119 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         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';
-import { to } from 'await-to-js';
-import { parseJSON } from './parse_json/parse_json.js';
 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 === WebSocket.OPEN) {
-            this.socket.close();
-        }
+        this.socket = new WebSocket(endpoint, options);
+        this.methodIdIncrement = 0;
+        this.callTimeout = 3000;
         this.events = new Map();
-        this.connectionTries = 0;
-        return new Promise(function (resolve, reject) {
-            _this.socket = new WebSocket(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);
-            });
-        });
-    };
-    WSRPC.prototype.tryReconnect = function () {
-        var _this = this;
-        this.connectionTries++;
-        if (this.connectionTries > this.maxConnectionTries) {
-            return;
-        }
-        this.socket = new WebSocket(this.endpoint, this.options);
-        this.socket.addEventListener("open", function () {
-            _this.connectionTries = 0;
+        this.socket.addEventListener("close", function () {
+            _this.events = new Map();
         });
-        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*/, 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 = 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);
+                    onMessage = function (msgEvent) {
+                        var eventData = _this.events.get(event);
+                        if (eventData && typeof msgEvent.data === "string") {
+                            try {
+                                var data_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*/, 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 === WebSocket.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*/, 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 timeoutId = null;
             var onMessage = function (msgEvent) {
                 if (typeof msgEvent.data === "string") {
-                    var data_1 = parseJSON(msgEvent.data);
+                    var data_2 = 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 === WebSocket.OPEN) {
                 _this.socket.send(body);
@@ -315,6 +180,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*/, 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)];
+                }
+            });
+        }); });
+    };
     return WSRPC;
 }());
 export { WSRPC };

package/dist/esm/wallet/websocket.js

@@ -24,29 +24,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 + 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 + RPCEvent.NewAsset, onData);
-    };
-    WalletMethods.prototype.onNewTransaction = function (onData) {
-        return this.ws.listenEvent(this.prefix + RPCEvent.NewTransaction, onData);
-    };
-    WalletMethods.prototype.onBalanceChanged = function (onData) {
-        return this.ws.listenEvent(this.prefix + RPCEvent.BalanceChanged, onData);
-    };
-    WalletMethods.prototype.onRescan = function (onData) {
-        return this.ws.listenEvent(this.prefix + RPCEvent.Rescan, onData);
-    };
-    WalletMethods.prototype.onHistorySynced = function (onData) {
-        return this.ws.listenEvent(this.prefix + RPCEvent.HistorySynced, onData);
-    };
-    WalletMethods.prototype.onOnline = function (onData) {
-        return this.ws.listenEvent(this.prefix + RPCEvent.Online, onData);
-    };
-    WalletMethods.prototype.onOffline = function (onData) {
-        return this.ws.listenEvent(this.prefix + RPCEvent.Offline, onData);
+    WalletMethods.prototype.listen = function (event, listener) {
+        this.ws.listen(this.prefix + event, listener);
     };
     WalletMethods.prototype.getVersion = function () {
         return this.dataCall(RPCMethod.GetVersion);
@@ -174,8 +156,8 @@ var WalletMethods = /** @class */ (function () {
 export { 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;
     }

package/dist/esm/xswd/relayer/app.js

@@ -15,7 +15,7 @@ var App = /** @class */ (function () {
         this.errElement.classList.add("xelis-xswd-relayer-error");
         this.qrCodeElement = document.createElement("div");
         this.qrCodeElement.classList.add("xelis-xswd-relayer-qrcode");
-        this.qrCodeElement.innerHTML = "\n            <div>XSWD Relayer</div>\n            <canvas></canvas>\n        ";
+        this.qrCodeElement.innerHTML = "\n            <div class=\"xelis-xswd-relayer-scan-logo\">\n                <svg fill=\"currentColor\" viewBox=\"0 0 24 24\" xmlns=\"http://www.w3.org/2000/svg\">\n                    <path d=\"M4,4h6v6H4V4M20,4v6H14V4h6M14,15h2V13H14V11h2v2h2V11h2v2H18v2h2v3H18v2H16V18H13v2H11V16h3V15m2,0v3h2V15H16M4,20V14h6v6H4M6,6V8H8V6H6M16,6V8h2V6H16M6,16v2H8V16H6M4,11H6v2H4V11m5,0h4v4H11V13H9V11m2-5h2v4H11V6M2,2V6H0V2A2,2,0,0,1,2,0H6V2H2M22,0a2,2,0,0,1,2,2V6H22V2H18V0h4M2,18v4H6v2H2a2,2,0,0,1-2-2V18H2m20,4V18h2v4a2,2,0,0,1-2,2H18V22Z\"/>\n                </svg>\n            </div>\n            <div class=\"xelis-xswd-relayer-logo-wrap\">\n                <div class=\"xelis-xswd-relayer-logo\">\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 778 743\" fill=\"currentColor\">\n                        <path fillRule=\"evenodd\" clipRule=\"evenodd\" d=\"M388.909 742.872L777.817 353.964L424.056 0.202599L478.809 132.737L700.036 353.964L388.909 665.091L77.7817 353.964L299.507 129.121L353.964 0L0 353.964L388.909 742.872Z\" />\n                        <path d=\"M388.909 665.091L353.964 0L299.507 129.121L388.909 665.091Z\" />\n                        <path d=\"M424.056 0.202599L388.909 665.091L478.809 132.737L424.056 0.202599Z\" />\n                    </svg>\n                </div>\n            </div>\n            <div class=\"xelis-xswd-relayer-title\">XSWD Relayer</div>\n            <canvas></canvas>\n        ";
         this.element.addEventListener("click", function (e) {
             // close the app if clicking outside
             if (_this.element.isEqualNode(e.target)) {
@@ -32,7 +32,7 @@ var App = /** @class */ (function () {
     };
     App.prototype.setError = function (msg) {
         this.clear();
-        this.errElement.innerHTML = "error: ".concat(msg);
+        this.errElement.innerHTML = "\n            <div class=\"xelis-xswd-relayer-error-text\">error: ".concat(msg, "</div>\n        ");
         this.contentElement.appendChild(this.errElement);
     };
     App.prototype.setLoading = function () {
@@ -48,7 +48,12 @@ var App = /** @class */ (function () {
             relayer: this.relayer.props.url,
             encryption_mode: this.relayer.props.encryption_mode
         });
-        QRCode.toCanvas(canvas, qrCodeData);
+        QRCode.toCanvas(canvas, qrCodeData, {
+            color: {
+                dark: "#fff",
+                light: "#000" // background
+            }
+        });
         this.contentElement.appendChild(this.qrCodeElement);
     };
     return App;

package/dist/esm/xswd/relayer/index.css

@@ -1,11 +1,21 @@
 .xelis-xswd-relayer {
+    font-family: system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", "Noto Sans", "Liberation Sans", Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
     position: fixed;
     top: 0;
     left: 0;
     bottom: 0;
     right: 0;
-    background-color: rgba(0, 0, 0, 0.5);
-    backdrop-filter: blur(10px);
+    background-color: rgba(0, 0, 0, 0.8);
+    backdrop-filter: blur(30px);
+    opacity: 0;
+    animation: xelis-xswd-relayer-appear .25s forwards;
+    user-select: none;
+}
+
+@keyframes xelis-xswd-relayer-appear {
+    100% {
+        opacity: 1;
+    }
 }
 
 .xelis-xswd-relayer-content {
@@ -13,16 +23,51 @@
     top: 50%;
     left: 50%;
     translate: -50% -50%;
-    background-color: aquamarine;
-    filter: drop-shadow(0px 0px 25px black);
 }
 
-.xelis-xswd-relayer-error {}
+.xelis-xswd-relayer-error {
+    background-color: #02ffcf;
+    padding: 15px;
+    border-radius: 10px;
+    animation: xelis-xswd-relayer-error-appear .5s forwards;
+    opacity: 0;
+}
+
+@keyframes xelis-xswd-relayer-error-appear {
+    25% {
+        translate: -4px 0;
+        rotate: -3deg;
+    }
+
+    50% {
+        translate: 4px 0;
+        rotate: 3deg;
+    }
+
+    75% {
+        translate: -4px 0;
+        rotate: -3deg;
+    }
+
+    100% {
+        opacity: 1;
+        translate: 0 0;
+        rotate: 0;
+    }
+}
+
+
+.xelis-xswd-relayer-error-text {
+    background-color: rgba(31, 31, 31, 1);
+    border-radius: 5px;
+    padding: 5px 10px;
+    color: rgb(255, 63, 63);
+}
 
 .xelis-xswd-relayer-loading {
-    width: 50px;
-    height: 50px;
-    color: black;
+    width: 75px;
+    height: 75px;
+    color: #02ffcf;
     animation: xelis-xswd-relayer-loading-animation .75s infinite;
 }
 
@@ -32,6 +77,87 @@
     }
 }
 
-.xelis-xswd-relayer-qrcode {}
+.xelis-xswd-relayer-qrcode {
+    background-color: rgba(2, 255, 207, 1);
+    padding: 30px 30px 50px 30px;
+    border-radius: 15px;
+    animation: xelis-xswd-relayer-qrcode-appear .25s forwards, xelis-xswd-relayer-qrcode-animation 2s infinite alternate;
+    translate: 0 -100%;
+    opacity: 0;
+    position: relative;
+}
+
+@keyframes xelis-xswd-relayer-qrcode-appear {
+    100% {
+        translate: 0 0;
+        opacity: 1;
+    }
+}
+
+@keyframes xelis-xswd-relayer-qrcode-animation {
+    0% {
+        background-color: rgba(2, 255, 207, 0.3);
+        filter: drop-shadow(0px 0px 100px rgba(2, 255, 209, 0.1));
+    }
+
+    100% {
+        background-color: rgba(2, 255, 207, 1);
+        filter: drop-shadow(0px 0px 200px rgba(2, 255, 209, 0.1));
+    }
+}
+
+.xelis-xswd-relayer-scan-logo {
+    position: absolute;
+    bottom: -30px;
+    left: 50%;
+    translate: -50% 0;
+    width: 25px;
+    height: 25px;
+    color: white;
+    background-color: black;
+    padding: 20px;
+    border-radius: 100%;
+}
+
+.xelis-xswd-relayer-logo-wrap {
+    position: absolute;
+    width: 100%;
+    height: 100%;
+    overflow: hidden;
+    top: 0;
+    left: 0;
+    border-radius: 15px;
+}
+
+.xelis-xswd-relayer-logo {
+    position: absolute;
+    width: 100%;
+    height: 100%;
+    top: 25%;
+    left: 5%;
+    scale: 1.8;
+    z-index: -1;
+    animation: xelis-xswd-relayer-logo-animation 2s infinite alternate;
+}
+
+@keyframes xelis-xswd-relayer-logo-animation {
+    0% {
+        color: rgba(0, 206, 168, 0);
+    }
+
+    100% {
+        color: rgba(0, 206, 168, 0.8);
+    }
+}
+
+
+.xelis-xswd-relayer-title {
+    font-size: 25px;
+    font-weight: bold;
+    margin-bottom: 10px;
+    color: black;
+}
 
-.xelis-xswd-relayer-qrcode canvas {}
+.xelis-xswd-relayer-qrcode canvas {
+    border-radius: 10px;
+}

package/dist/esm/xswd/websocket.js

@@ -18,9 +18,9 @@ import { DaemonMethods } from '../daemon/websocket.js';
 import { WalletMethods } from '../wallet/websocket.js';
 var WS = /** @class */ (function (_super) {
     __extends(WS, _super);
-    function WS() {
-        var _this = _super.call(this) || this;
-        _this.timeout = 0;
+    function WS(endpoint) {
+        var _this = _super.call(this, endpoint) || this;
+        _this.callTimeout = 0; // xswd needs user input for confirmation - timeout should not be used
         _this.daemon = new DaemonMethods(_this, "node.");
         _this.wallet = new WalletMethods(_this, "wallet.");
         return _this;