@xelis/sdk 0.7.0 → 0.8.0

package/dist/cjs/lib/websocket.js

@@ -0,0 +1,283 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.WS = void 0;
+var isomorphic_ws_1 = __importDefault(require("isomorphic-ws"));
+var await_to_js_1 = __importDefault(require("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 === isomorphic_ws_1["default"].OPEN) {
+            this.socket.close();
+        }
+        this.events = {};
+        this.connectionTries = 0;
+        return new Promise(function (resolve, reject) {
+            _this.socket = new isomorphic_ws_1["default"](endpoint, _this.options);
+            _this.endpoint = endpoint;
+            _this.socket.addEventListener("open", function (event) {
+                resolve(event);
+            });
+            _this.socket.addEventListener("close", function (event) {
+                if (_this.reconnectOnConnectionLoss && !event.wasClean) {
+                    _this.tryReconnect();
+                    reject(new Error("Unhandled close. Reconnecting..."));
+                }
+                else {
+                    reject(event);
+                }
+            });
+            _this.socket.addEventListener("error", function (err) {
+                reject(err);
+            });
+        });
+    };
+    WS.prototype.tryReconnect = function () {
+        var _this = this;
+        this.connectionTries++;
+        if (this.connectionTries > this.maxConnectionTries) {
+            return;
+        }
+        this.socket = new isomorphic_ws_1["default"](this.endpoint, this.options);
+        this.socket.addEventListener("open", function () {
+            _this.connectionTries = 0;
+        });
+        this.socket.addEventListener("close", function (event) {
+            _this.tryReconnect();
+        });
+    };
+    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*/, (0, await_to_js_1["default"])(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*/, (0, await_to_js_1["default"])(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 === isomorphic_ws_1["default"].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 !== 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 = 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 === isomorphic_ws_1["default"].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*/, (0, await_to_js_1["default"])(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;
+}());
+exports.WS = WS;

package/dist/cjs/react/daemon.js

@@ -0,0 +1,176 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.useNodeSocket = exports.useNodeSocketSubscribe = exports.NodeSocketProvider = exports.INITIATING = void 0;
+var react_1 = __importStar(require("react"));
+var await_to_js_1 = __importDefault(require("await-to-js"));
+var websocket_1 = __importDefault(require("../daemon/websocket"));
+exports.INITIATING = -1;
+var daemon = new websocket_1["default"]();
+var Context = (0, react_1.createContext)({
+    err: undefined,
+    daemon: daemon,
+    readyState: exports.INITIATING
+});
+var NodeSocketProvider = function (props) {
+    var children = props.children, endpoint = props.endpoint, timeout = props.timeout;
+    var _a = (0, react_1.useState)(exports.INITIATING), readyState = _a[0], setReadyState = _a[1];
+    var _b = (0, react_1.useState)(), err = _b[0], setErr = _b[1];
+    (0, react_1.useEffect)(function () {
+        var connect = function () { return __awaiter(void 0, void 0, void 0, function () {
+            var _a, err, _;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        setErr(undefined);
+                        return [4 /*yield*/, (0, await_to_js_1["default"])(daemon.connect(endpoint))];
+                    case 1:
+                        _a = _b.sent(), err = _a[0], _ = _a[1];
+                        if (err)
+                            setErr(err);
+                        return [2 /*return*/];
+                }
+            });
+        }); };
+        connect();
+    }, [endpoint]);
+    (0, react_1.useEffect)(function () {
+        if (!timeout)
+            return;
+        daemon.timeout = timeout;
+    }, [timeout]);
+    (0, react_1.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_1["default"].createElement(Context.Provider, { value: { daemon: daemon, err: err, readyState: readyState } }, children);
+};
+exports.NodeSocketProvider = NodeSocketProvider;
+var useNodeSocketSubscribe = function (_a, dependencies) {
+    var event = _a.event, onLoad = _a.onLoad, onData = _a.onData;
+    var nodeSocket = (0, exports.useNodeSocket)();
+    (0, react_1.useEffect)(function () {
+        if (nodeSocket.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));
+};
+exports.useNodeSocketSubscribe = useNodeSocketSubscribe;
+var useNodeSocket = function () { return (0, react_1.useContext)(Context); };
+exports.useNodeSocket = useNodeSocket;
+exports["default"] = exports.useNodeSocket;

package/dist/cjs/wallet/rpc.js

@@ -0,0 +1,131 @@
+"use strict";
+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 };
+    }
+};
+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 RPC = /** @class */ (function (_super) {
+    __extends(RPC, _super);
+    function RPC(endpoint, username, password) {
+        var _this = _super.call(this, endpoint) || this;
+        var authValue = js_base64_1.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(types_1.RPCMethod.GetVersion);
+    };
+    RPC.prototype.getNetwork = function () {
+        return this.post(types_1.RPCMethod.GetNetwork);
+    };
+    RPC.prototype.getNonce = function () {
+        return this.post(types_1.RPCMethod.GetNonce);
+    };
+    RPC.prototype.getTopoheight = function () {
+        return this.post(types_1.RPCMethod.GetTopoheight);
+    };
+    RPC.prototype.getAddress = function (params) {
+        if (params === void 0) { params = {}; }
+        return this.post(types_1.RPCMethod.GetAddress, params);
+    };
+    RPC.prototype.splitAddress = function (params) {
+        return this.post(types_1.RPCMethod.SplitAddress, params);
+    };
+    RPC.prototype.rescan = function () {
+        return this.post(types_1.RPCMethod.Rescan);
+    };
+    RPC.prototype.getBalance = function (asset) {
+        return this.post(types_1.RPCMethod.GetBalance, { asset: asset });
+    };
+    RPC.prototype.hasBalance = function (asset) {
+        return this.post(types_1.RPCMethod.HasBalance, { asset: asset });
+    };
+    RPC.prototype.getTrackedAssets = function () {
+        return this.post(types_1.RPCMethod.GetTrackedAssets);
+    };
+    RPC.prototype.getAssetPrecision = function (params) {
+        return this.post(types_1.RPCMethod.GetAssetPrecision, params);
+    };
+    RPC.prototype.getTransaction = function (hash) {
+        return this.post(types_1.RPCMethod.GetTransaction, { hash: hash });
+    };
+    RPC.prototype.buildTransaction = function (params) {
+        return this.post(types_1.RPCMethod.BuildTransaction, params);
+    };
+    RPC.prototype.listTransactions = function (params) {
+        return this.post(types_1.RPCMethod.ListTransactions, params);
+    };
+    RPC.prototype.isOnline = function () {
+        return this.post(types_1.RPCMethod.IsOnline);
+    };
+    RPC.prototype.signData = function (data) {
+        return this.post(types_1.RPCMethod.SignData, data);
+    };
+    RPC.prototype.estimateFees = function (txData) {
+        return this.post(types_1.RPCMethod.EstimateFees, { tx_type: txData });
+    };
+    return RPC;
+}(rpc_1.RPC));
+exports.RPC = RPC;
+exports["default"] = RPC;

package/dist/cjs/wallet/types.js

@@ -0,0 +1,29 @@
+"use strict";
+exports.__esModule = true;
+exports.Permission = exports.RPCMethod = void 0;
+var RPCMethod;
+(function (RPCMethod) {
+    RPCMethod["GetVersion"] = "get_version";
+    RPCMethod["GetNetwork"] = "get_network";
+    RPCMethod["GetNonce"] = "get_nonce";
+    RPCMethod["GetTopoheight"] = "get_topoheight";
+    RPCMethod["GetAddress"] = "get_address";
+    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";
+    RPCMethod["BuildTransaction"] = "build_transaction";
+    RPCMethod["ListTransactions"] = "list_transactions";
+    RPCMethod["IsOnline"] = "is_online";
+    RPCMethod["SignData"] = "sign_data";
+    RPCMethod["EstimateFees"] = "estimate_fees";
+})(RPCMethod = exports.RPCMethod || (exports.RPCMethod = {}));
+var Permission;
+(function (Permission) {
+    Permission[Permission["Ask"] = 0] = "Ask";
+    Permission[Permission["AcceptAlways"] = 1] = "AcceptAlways";
+    Permission[Permission["DenyAlways"] = 2] = "DenyAlways";
+})(Permission = exports.Permission || (exports.Permission = {}));