@xelis/sdk 0.6.1 → 0.8.0

package/dist/esm/lib/websocket.js

@@ -0,0 +1,277 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import WebSocket from 'isomorphic-ws';
+import to from 'await-to-js';
+var WS = /** @class */ (function () {
+    function WS(options) {
+        this.connectionTries = 0;
+        this.methodIdIncrement = 0;
+        this.endpoint = "";
+        this.timeout = 15000; // default to 15s
+        this.events = {};
+        this.unsubscribeSuspense = 1000;
+        this.maxConnectionTries = 3;
+        this.reconnectOnConnectionLoss = true;
+        this.options = options;
+    }
+    WS.prototype.connect = function (endpoint) {
+        var _this = this;
+        // force disconnect if already connected
+        if (this.socket && this.socket.readyState === WebSocket.OPEN) {
+            this.socket.close();
+        }
+        this.events = {};
+        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);
+            });
+        });
+    };
+    WS.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 (event) {
+            _this.tryReconnect();
+        });
+    };
+    WS.prototype.close = function () {
+        if (!this.socket)
+            return;
+        this.socket.close();
+    };
+    WS.prototype.clearEvent = function (event) {
+        var _this = this;
+        this.events[event].listeners.forEach(function (listener) {
+            _this.socket && _this.socket.removeEventListener("message", listener);
+        });
+        Reflect.deleteProperty(this.events, event);
+    };
+    WS.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[event]) return [3 /*break*/, 2];
+                        return [4 /*yield*/, to(this.call("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()];
+                }
+            });
+        });
+    };
+    WS.prototype.listenEvent = function (event, onData) {
+        return __awaiter(this, void 0, void 0, function () {
+            var onMessage, unsubscribeTimeoutId, _a, err, res, closeListen;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        onMessage = function (msgEvent) {
+                            if (_this.events[event]) {
+                                var id = _this.events[event].id;
+                                if (typeof msgEvent.data === "string") {
+                                    try {
+                                        var data = JSON.parse(msgEvent.data);
+                                        if (data.id === 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
+                                    }
+                                }
+                            }
+                        };
+                        if (!this.events[event]) return [3 /*break*/, 1];
+                        unsubscribeTimeoutId = this.events[event].unsubscribeTimeoutId;
+                        if (unsubscribeTimeoutId) {
+                            // clear timeout to unsubscribe 
+                            // because we got a new registered event and want to cancel the pending unsubscribe grace period
+                            clearTimeout(unsubscribeTimeoutId);
+                        }
+                        this.events[event].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
+                        this.events[event] = { listeners: [onMessage] };
+                        return [4 /*yield*/, to(this.call("subscribe", { notify: event }))];
+                    case 2:
+                        _a = _b.sent(), err = _a[0], res = _a[1];
+                        if (err) {
+                            this.clearEvent(event);
+                            return [2 /*return*/, Promise.reject(err)];
+                        }
+                        this.events[event].id = res.id;
+                        _b.label = 3;
+                    case 3:
+                        this.socket && this.socket.addEventListener("message", onMessage);
+                        closeListen = function () {
+                            var eventData = _this.events[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) {
+                                    if (_this.socket && _this.socket.readyState === WebSocket.OPEN) {
+                                        // we use a grace period to unsubscribe (mostly because of react useEffect and avoid unecessary subscribe)
+                                        _this.events[event].unsubscribeTimeoutId = setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
+                                            return __generator(this, function (_a) {
+                                                this.call("unsubscribe", { notify: event });
+                                                Reflect.deleteProperty(this.events, event);
+                                                return [2 /*return*/];
+                                            });
+                                        }); }, _this.unsubscribeSuspense);
+                                    }
+                                    else {
+                                        // socket is closed so we don't send unsubscribe and no grace period delete right away
+                                        Reflect.deleteProperty(_this.events, event);
+                                    }
+                                }
+                            }
+                            _this.socket && _this.socket.removeEventListener("message", onMessage);
+                            return Promise.resolve();
+                        };
+                        return [2 /*return*/, Promise.resolve(closeListen)];
+                }
+            });
+        });
+    };
+    WS.prototype.call = function (method, params, overwriteData) {
+        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 = JSON.parse(msgEvent.data);
+                    if (data.id === requestMethod.id) {
+                        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
+            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);
+            }
+        });
+    };
+    WS.prototype.dataCall = function (method, params) {
+        var _this = this;
+        return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+            var _a, err, res;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, to(this.call(method, params))];
+                    case 1:
+                        _a = _b.sent(), err = _a[0], res = _a[1];
+                        if (err)
+                            return [2 /*return*/, reject(err)];
+                        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;
+}());
+export { WS };

package/dist/esm/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/dist/esm/react/daemon.js

@@ -0,0 +1,144 @@
+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)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import React, { createContext, useContext, useEffect, useState } from 'react';
+import to from 'await-to-js';
+import DaemonWS from '../daemon/websocket';
+export var INITIATING = -1;
+var daemon = new DaemonWS();
+var Context = createContext({
+    err: undefined,
+    daemon: daemon,
+    readyState: INITIATING
+});
+export var NodeSocketProvider = function (props) {
+    var children = props.children, endpoint = props.endpoint, timeout = props.timeout;
+    var _a = useState(INITIATING), readyState = _a[0], setReadyState = _a[1];
+    var _b = useState(), err = _b[0], setErr = _b[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*/, to(daemon.connect(endpoint))];
+                    case 1:
+                        _a = _b.sent(), err = _a[0], _ = _a[1];
+                        if (err)
+                            setErr(err);
+                        return [2 /*return*/];
+                }
+            });
+        }); };
+        connect();
+    }, [endpoint]);
+    useEffect(function () {
+        if (!timeout)
+            return;
+        daemon.timeout = timeout;
+    }, [timeout]);
+    useEffect(function () {
+        if (!daemon.socket)
+            return;
+        setReadyState(daemon.socket.readyState);
+        var onOpen = function () {
+            if (!daemon.socket)
+                return;
+            setReadyState(daemon.socket.readyState);
+            setErr(undefined);
+        };
+        var onClose = function (event) {
+            if (!daemon.socket)
+                return;
+            setReadyState(daemon.socket.readyState);
+            setErr(new Error(event.reason));
+        };
+        var onError = function (err) {
+            if (!daemon.socket)
+                return;
+            setReadyState(daemon.socket.readyState);
+            setErr(new Error(err.message));
+        };
+        daemon.socket.addEventListener("open", onOpen);
+        daemon.socket.addEventListener("close", onClose);
+        daemon.socket.addEventListener("error", onError);
+        return function () {
+            if (!daemon.socket)
+                return;
+            daemon.socket.removeEventListener("open", onOpen);
+            daemon.socket.removeEventListener("close", onClose);
+            daemon.socket.removeEventListener("error", onError);
+        };
+    }, [daemon.socket]);
+    return React.createElement(Context.Provider, { value: { daemon: daemon, err: err, readyState: readyState } }, children);
+};
+export var useNodeSocketSubscribe = function (_a, dependencies) {
+    var event = _a.event, onLoad = _a.onLoad, onData = _a.onData;
+    var nodeSocket = useNodeSocket();
+    useEffect(function () {
+        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();
+        return function () {
+            closeEvent && closeEvent();
+        };
+    }, __spreadArray([nodeSocket], dependencies, true));
+};
+export var useNodeSocket = function () { return useContext(Context); };
+export default useNodeSocket;

package/dist/esm/wallet/rpc.js

@@ -0,0 +1,128 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { Base64 } from 'js-base64';
+import { RPCMethod } from './types';
+import { RPC as BaseRPC } from '../lib/rpc';
+var RPC = /** @class */ (function (_super) {
+    __extends(RPC, _super);
+    function RPC(endpoint, username, password) {
+        var _this = _super.call(this, endpoint) || this;
+        var authValue = Base64.encode("".concat(username, ":").concat(password));
+        _this.auth = "Basic ".concat(authValue);
+        return _this;
+    }
+    RPC.prototype.post = function (method, params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var headers;
+            return __generator(this, function (_a) {
+                headers = new Headers();
+                headers.set("Authorization", this.auth);
+                return [2 /*return*/, _super.prototype.post.call(this, method, params, headers)];
+            });
+        });
+    };
+    RPC.prototype.getVersion = function () {
+        return this.post(RPCMethod.GetVersion);
+    };
+    RPC.prototype.getNetwork = function () {
+        return this.post(RPCMethod.GetNetwork);
+    };
+    RPC.prototype.getNonce = function () {
+        return this.post(RPCMethod.GetNonce);
+    };
+    RPC.prototype.getTopoheight = function () {
+        return this.post(RPCMethod.GetTopoheight);
+    };
+    RPC.prototype.getAddress = function (params) {
+        if (params === void 0) { params = {}; }
+        return this.post(RPCMethod.GetAddress, params);
+    };
+    RPC.prototype.splitAddress = function (params) {
+        return this.post(RPCMethod.SplitAddress, params);
+    };
+    RPC.prototype.rescan = function () {
+        return this.post(RPCMethod.Rescan);
+    };
+    RPC.prototype.getBalance = function (asset) {
+        return this.post(RPCMethod.GetBalance, { asset: asset });
+    };
+    RPC.prototype.hasBalance = function (asset) {
+        return this.post(RPCMethod.HasBalance, { asset: asset });
+    };
+    RPC.prototype.getTrackedAssets = function () {
+        return this.post(RPCMethod.GetTrackedAssets);
+    };
+    RPC.prototype.getAssetPrecision = function (params) {
+        return this.post(RPCMethod.GetAssetPrecision, params);
+    };
+    RPC.prototype.getTransaction = function (hash) {
+        return this.post(RPCMethod.GetTransaction, { hash: hash });
+    };
+    RPC.prototype.buildTransaction = function (params) {
+        return this.post(RPCMethod.BuildTransaction, params);
+    };
+    RPC.prototype.listTransactions = function (params) {
+        return this.post(RPCMethod.ListTransactions, params);
+    };
+    RPC.prototype.isOnline = function () {
+        return this.post(RPCMethod.IsOnline);
+    };
+    RPC.prototype.signData = function (data) {
+        return this.post(RPCMethod.SignData, data);
+    };
+    RPC.prototype.estimateFees = function (txData) {
+        return this.post(RPCMethod.EstimateFees, { tx_type: txData });
+    };
+    return RPC;
+}(BaseRPC));
+export { RPC };
+export default RPC;

package/{wallet → dist/esm/wallet}/types.js

@@ -8,6 +8,7 @@ export var RPCMethod;
     RPCMethod["SplitAddress"] = "split_address";
     RPCMethod["Rescan"] = "rescan";
     RPCMethod["GetBalance"] = "get_balance";
+    RPCMethod["HasBalance"] = "has_balance";
     RPCMethod["GetTrackedAssets"] = "get_tracked_assets";
     RPCMethod["GetAssetPrecision"] = "get_asset_precision";
     RPCMethod["GetTransaction"] = "get_transaction";

package/dist/esm/wallet/websocket.js

@@ -0,0 +1,89 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { WS as BaseWS } from '../lib/websocket';
+import { RPCMethod } from './types';
+var WalletMethods = /** @class */ (function () {
+    function WalletMethods(ws, prefix) {
+        if (prefix === void 0) { prefix = ""; }
+        this.ws = ws;
+        this.prefix = prefix;
+    }
+    WalletMethods.prototype.dataCall = function (method, params) {
+        return this.ws.dataCall(this.prefix + method, params);
+    };
+    WalletMethods.prototype.getVersion = function () {
+        return this.dataCall(RPCMethod.GetVersion);
+    };
+    WalletMethods.prototype.getNetwork = function () {
+        return this.dataCall(RPCMethod.GetNetwork);
+    };
+    WalletMethods.prototype.getNonce = function () {
+        return this.dataCall(RPCMethod.GetNonce);
+    };
+    WalletMethods.prototype.getTopoheight = function () {
+        return this.dataCall(RPCMethod.GetTopoheight);
+    };
+    WalletMethods.prototype.getAddress = function (params) {
+        if (params === void 0) { params = {}; }
+        return this.dataCall(RPCMethod.GetAddress, params);
+    };
+    WalletMethods.prototype.splitAddress = function (params) {
+        return this.dataCall(RPCMethod.SplitAddress, params);
+    };
+    WalletMethods.prototype.rescan = function () {
+        return this.dataCall(RPCMethod.Rescan);
+    };
+    WalletMethods.prototype.getBalance = function (asset) {
+        return this.dataCall(RPCMethod.GetBalance, { asset: asset });
+    };
+    WalletMethods.prototype.getTrackedAssets = function () {
+        return this.dataCall(RPCMethod.GetTrackedAssets);
+    };
+    WalletMethods.prototype.getAssetPrecision = function (params) {
+        return this.dataCall(RPCMethod.GetAssetPrecision, params);
+    };
+    WalletMethods.prototype.getTransaction = function (hash) {
+        return this.dataCall(RPCMethod.GetTransaction, { hash: hash });
+    };
+    WalletMethods.prototype.buildTransaction = function (params) {
+        return this.dataCall(RPCMethod.BuildTransaction, params);
+    };
+    WalletMethods.prototype.listTransactions = function (params) {
+        return this.dataCall(RPCMethod.GetTransaction, params);
+    };
+    WalletMethods.prototype.isOnline = function () {
+        return this.dataCall(RPCMethod.IsOnline);
+    };
+    WalletMethods.prototype.signData = function (data) {
+        return this.dataCall(RPCMethod.SignData, data);
+    };
+    WalletMethods.prototype.estimateFees = function (txData) {
+        return this.dataCall(RPCMethod.EstimateFees, { tx_type: txData });
+    };
+    return WalletMethods;
+}());
+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;
+        _this.methods = new WalletMethods(_this);
+        return _this;
+    }
+    return WS;
+}(BaseWS));
+export { WS };
+export default WS;