@xelis/sdk 0.11.14 → 0.11.16

package/dist/cjs/wallet/rpc.js

@@ -1,154 +1,135 @@
 "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 __());
-    };
-})();
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.RPC = void 0;
-var js_base64_1 = require("js-base64");
-var types_1 = require("./types");
-var http_1 = require("../rpc/http");
-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.headers.set("Authorization", "Basic ".concat(authValue));
-        return _this;
-    }
-    RPC.prototype.getVersion = function () {
+const js_base64_1 = require("js-base64");
+const types_1 = require("./types");
+const http_1 = require("../rpc/http");
+class RPC extends http_1.HttpRPC {
+    constructor(endpoint, username, password) {
+        super(endpoint);
+        const authValue = js_base64_1.Base64.encode(`${username}:${password}`);
+        this.headers.set("Authorization", `Basic ${authValue}`);
+    }
+    getVersion() {
         return this.request(types_1.RPCMethod.GetVersion);
-    };
-    RPC.prototype.getNetwork = function () {
+    }
+    getNetwork() {
         return this.request(types_1.RPCMethod.GetNetwork);
-    };
-    RPC.prototype.getNonce = function () {
+    }
+    getNonce() {
         return this.request(types_1.RPCMethod.GetNonce);
-    };
-    RPC.prototype.getTopoheight = function () {
+    }
+    getTopoheight() {
         return this.request(types_1.RPCMethod.GetTopoheight);
-    };
-    RPC.prototype.getAddress = function (params) {
-        if (params === void 0) { params = {}; }
+    }
+    getAddress(params = {}) {
         return this.request(types_1.RPCMethod.GetAddress, params);
-    };
-    RPC.prototype.splitAddress = function (params) {
+    }
+    splitAddress(params) {
         return this.request(types_1.RPCMethod.SplitAddress, params);
-    };
-    RPC.prototype.rescan = function (params) {
+    }
+    rescan(params) {
         return this.request(types_1.RPCMethod.Rescan, params);
-    };
-    RPC.prototype.getBalance = function (asset) {
-        return this.request(types_1.RPCMethod.GetBalance, { asset: asset });
-    };
-    RPC.prototype.hasBalance = function (asset) {
-        return this.request(types_1.RPCMethod.HasBalance, { asset: asset });
-    };
-    RPC.prototype.getTrackedAssets = function () {
+    }
+    getBalance(asset) {
+        return this.request(types_1.RPCMethod.GetBalance, { asset });
+    }
+    hasBalance(asset) {
+        return this.request(types_1.RPCMethod.HasBalance, { asset });
+    }
+    getTrackedAssets() {
         return this.request(types_1.RPCMethod.GetTrackedAssets);
-    };
-    RPC.prototype.getAssetPrecision = function (params) {
+    }
+    getAssetPrecision(params) {
         return this.request(types_1.RPCMethod.GetAssetPrecision, params);
-    };
-    RPC.prototype.getAssets = function () {
+    }
+    getAssets() {
         return this.request(types_1.RPCMethod.GetAssets);
-    };
-    RPC.prototype.getAsset = function (params) {
+    }
+    getAsset(params) {
         return this.request(types_1.RPCMethod.GetAsset, params);
-    };
-    RPC.prototype.getTransaction = function (hash) {
-        return this.request(types_1.RPCMethod.GetTransaction, { hash: hash });
-    };
-    RPC.prototype.searchTransaction = function (hash) {
-        return this.request(types_1.RPCMethod.SearchTransaction, { hash: hash });
-    };
-    RPC.prototype.dumpTransaction = function (hash) {
-        return this.request(types_1.RPCMethod.DumpTransaction, { hash: hash });
-    };
-    RPC.prototype.buildTransaction = function (params) {
+    }
+    getTransaction(hash) {
+        return this.request(types_1.RPCMethod.GetTransaction, { hash });
+    }
+    searchTransaction(hash) {
+        return this.request(types_1.RPCMethod.SearchTransaction, { hash });
+    }
+    dumpTransaction(hash) {
+        return this.request(types_1.RPCMethod.DumpTransaction, { hash });
+    }
+    buildTransaction(params) {
         return this.request(types_1.RPCMethod.BuildTransaction, params);
-    };
-    RPC.prototype.buildTransactionOffline = function (params) {
+    }
+    buildTransactionOffline(params) {
         return this.request(types_1.RPCMethod.BuildTransactionOffline, params);
-    };
-    RPC.prototype.buildUnsignedTransaction = function (params) {
+    }
+    buildUnsignedTransaction(params) {
         return this.request(types_1.RPCMethod.BuildUnsignedTransaction, params);
-    };
-    RPC.prototype.signUnsignedTransaction = function (params) {
+    }
+    signUnsignedTransaction(params) {
         return this.request(types_1.RPCMethod.SignUnsignedTransaction, params);
-    };
-    RPC.prototype.finalizeUnsignedTransaction = function (params) {
+    }
+    finalizeUnsignedTransaction(params) {
         return this.request(types_1.RPCMethod.FinalizeUnsignedTransaction, params);
-    };
-    RPC.prototype.clearTxCache = function () {
+    }
+    clearTxCache() {
         return this.request(types_1.RPCMethod.ClearTxCache);
-    };
-    RPC.prototype.listTransactions = function (params) {
+    }
+    listTransactions(params) {
         return this.request(types_1.RPCMethod.ListTransactions, params);
-    };
-    RPC.prototype.isOnline = function () {
+    }
+    isOnline() {
         return this.request(types_1.RPCMethod.IsOnline);
-    };
-    RPC.prototype.setOnlineMode = function (params) {
+    }
+    setOnlineMode(params) {
         return this.request(types_1.RPCMethod.SetOnlineMode, params);
-    };
-    RPC.prototype.setOfflineMode = function () {
+    }
+    setOfflineMode() {
         return this.request(types_1.RPCMethod.SetOfflineMode);
-    };
-    RPC.prototype.signData = function (data) {
+    }
+    signData(data) {
         return this.request(types_1.RPCMethod.SignData, data.toObject());
-    };
-    RPC.prototype.estimateFees = function (params) {
+    }
+    estimateFees(params) {
         return this.request(types_1.RPCMethod.EstimateFees, params);
-    };
-    RPC.prototype.estimateExtraDataSize = function (params) {
+    }
+    estimateExtraDataSize(params) {
         return this.request(types_1.RPCMethod.EstimateExtraDataSize, params);
-    };
-    RPC.prototype.networkInfo = function () {
+    }
+    networkInfo() {
         return this.request(types_1.RPCMethod.NetworkInfo);
-    };
-    RPC.prototype.decryptExtraData = function (params) {
+    }
+    decryptExtraData(params) {
         return this.request(types_1.RPCMethod.DecryptExtraData, params);
-    };
-    RPC.prototype.decryptCiphertext = function (params) {
+    }
+    decryptCiphertext(params) {
         return this.request(types_1.RPCMethod.DecryptCiphertext, params);
-    };
-    RPC.prototype.getMatchingKeys = function (params) {
+    }
+    getMatchingKeys(params) {
         return this.request(types_1.RPCMethod.GetMatchingKeys, params);
-    };
-    RPC.prototype.countMatchingEntries = function (params) {
+    }
+    countMatchingEntries(params) {
         return this.request(types_1.RPCMethod.CountMatchingEntries, params);
-    };
-    RPC.prototype.getValueFromKey = function (params) {
+    }
+    getValueFromKey(params) {
         return this.request(types_1.RPCMethod.GetValueFromKey, params);
-    };
-    RPC.prototype.store = function (params) {
+    }
+    store(params) {
         return this.request(types_1.RPCMethod.Store, params);
-    };
-    RPC.prototype["delete"] = function (params) {
+    }
+    delete(params) {
         return this.request(types_1.RPCMethod.Delete, params);
-    };
-    RPC.prototype.deleteTreeEntries = function (tree) {
-        return this.request(types_1.RPCMethod.DeleteTreeEntries, { tree: tree });
-    };
-    RPC.prototype.hasKey = function (params) {
+    }
+    deleteTreeEntries(tree) {
+        return this.request(types_1.RPCMethod.DeleteTreeEntries, { tree });
+    }
+    hasKey(params) {
         return this.request(types_1.RPCMethod.HasKey, params);
-    };
-    RPC.prototype.queryDB = function (params) {
+    }
+    queryDB(params) {
         return this.request(types_1.RPCMethod.QueryDB, params);
-    };
-    return RPC;
-}(http_1.HttpRPC));
+    }
+}
 exports.RPC = RPC;
-exports["default"] = RPC;
+exports.default = RPC;

package/dist/cjs/wallet/types.js

@@ -1,5 +1,5 @@
 "use strict";
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.RPCEvent = exports.RPCMethod = exports.ElementType = exports.ValueType = exports.TxRole = void 0;
 var TxRole;
 (function (TxRole) {

package/dist/cjs/wallet/websocket.js

@@ -1,170 +1,149 @@
 "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 __());
-    };
-})();
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.WS = exports.WalletMethods = void 0;
-var websocket_1 = require("../rpc/websocket");
-var types_1 = require("./types");
-var WalletMethods = /** @class */ (function () {
-    function WalletMethods(ws, prefix) {
-        if (prefix === void 0) { prefix = ""; }
+const websocket_1 = require("../rpc/websocket");
+const types_1 = require("./types");
+class WalletMethods {
+    constructor(ws, prefix = "") {
         this.ws = ws;
         this.prefix = prefix;
     }
-    WalletMethods.prototype.dataCall = function (method, params) {
+    dataCall(method, params) {
         return this.ws.dataCall(this.prefix + method, params);
-    };
-    WalletMethods.prototype.closeListener = function (event, listener) {
+    }
+    closeListener(event, listener) {
         this.ws.closeListener(event, listener);
-    };
-    WalletMethods.prototype.listen = function (event, listener) {
+    }
+    listen(event, listener) {
         this.ws.listen(this.prefix + event, listener);
-    };
-    WalletMethods.prototype.getVersion = function () {
+    }
+    getVersion() {
         return this.dataCall(types_1.RPCMethod.GetVersion);
-    };
-    WalletMethods.prototype.getNetwork = function () {
+    }
+    getNetwork() {
         return this.dataCall(types_1.RPCMethod.GetNetwork);
-    };
-    WalletMethods.prototype.getNonce = function () {
+    }
+    getNonce() {
         return this.dataCall(types_1.RPCMethod.GetNonce);
-    };
-    WalletMethods.prototype.getTopoheight = function () {
+    }
+    getTopoheight() {
         return this.dataCall(types_1.RPCMethod.GetTopoheight);
-    };
-    WalletMethods.prototype.getAddress = function (params) {
-        if (params === void 0) { params = {}; }
+    }
+    getAddress(params = {}) {
         return this.dataCall(types_1.RPCMethod.GetAddress, params);
-    };
-    WalletMethods.prototype.splitAddress = function (params) {
+    }
+    splitAddress(params) {
         return this.dataCall(types_1.RPCMethod.SplitAddress, params);
-    };
-    WalletMethods.prototype.rescan = function (params) {
+    }
+    rescan(params) {
         return this.dataCall(types_1.RPCMethod.Rescan, params);
-    };
-    WalletMethods.prototype.getBalance = function (asset) {
-        return this.dataCall(types_1.RPCMethod.GetBalance, { asset: asset });
-    };
-    WalletMethods.prototype.hasBalance = function (asset) {
-        return this.dataCall(types_1.RPCMethod.HasBalance, { asset: asset });
-    };
-    WalletMethods.prototype.getTrackedAssets = function () {
+    }
+    getBalance(asset) {
+        return this.dataCall(types_1.RPCMethod.GetBalance, { asset });
+    }
+    hasBalance(asset) {
+        return this.dataCall(types_1.RPCMethod.HasBalance, { asset });
+    }
+    getTrackedAssets() {
         return this.dataCall(types_1.RPCMethod.GetTrackedAssets);
-    };
-    WalletMethods.prototype.getAssetPrecision = function (params) {
+    }
+    getAssetPrecision(params) {
         return this.dataCall(types_1.RPCMethod.GetAssetPrecision, params);
-    };
-    WalletMethods.prototype.getAssets = function () {
+    }
+    getAssets() {
         return this.dataCall(types_1.RPCMethod.GetAssets);
-    };
-    WalletMethods.prototype.getAsset = function (params) {
+    }
+    getAsset(params) {
         return this.dataCall(types_1.RPCMethod.GetAsset, params);
-    };
-    WalletMethods.prototype.getTransaction = function (hash) {
-        return this.dataCall(types_1.RPCMethod.GetTransaction, { hash: hash });
-    };
-    WalletMethods.prototype.searchTransaction = function (hash) {
-        return this.dataCall(types_1.RPCMethod.SearchTransaction, { hash: hash });
-    };
-    WalletMethods.prototype.dumpTransaction = function (hash) {
-        return this.dataCall(types_1.RPCMethod.DumpTransaction, { hash: hash });
-    };
-    WalletMethods.prototype.buildTransaction = function (params) {
+    }
+    getTransaction(hash) {
+        return this.dataCall(types_1.RPCMethod.GetTransaction, { hash });
+    }
+    searchTransaction(hash) {
+        return this.dataCall(types_1.RPCMethod.SearchTransaction, { hash });
+    }
+    dumpTransaction(hash) {
+        return this.dataCall(types_1.RPCMethod.DumpTransaction, { hash });
+    }
+    buildTransaction(params) {
         return this.dataCall(types_1.RPCMethod.BuildTransaction, params);
-    };
-    WalletMethods.prototype.buildTransactionOffline = function (params) {
+    }
+    buildTransactionOffline(params) {
         return this.dataCall(types_1.RPCMethod.BuildTransactionOffline, params);
-    };
-    WalletMethods.prototype.buildUnsignedTransaction = function (params) {
+    }
+    buildUnsignedTransaction(params) {
         return this.dataCall(types_1.RPCMethod.BuildUnsignedTransaction, params);
-    };
-    WalletMethods.prototype.signUnsignedTransaction = function (params) {
+    }
+    signUnsignedTransaction(params) {
         return this.dataCall(types_1.RPCMethod.SignUnsignedTransaction, params);
-    };
-    WalletMethods.prototype.finalizeUnsignedTransaction = function (params) {
+    }
+    finalizeUnsignedTransaction(params) {
         return this.dataCall(types_1.RPCMethod.FinalizeUnsignedTransaction, params);
-    };
-    WalletMethods.prototype.clearTxCache = function () {
+    }
+    clearTxCache() {
         return this.dataCall(types_1.RPCMethod.ClearTxCache);
-    };
-    WalletMethods.prototype.listTransactions = function (params) {
+    }
+    listTransactions(params) {
         return this.dataCall(types_1.RPCMethod.GetTransaction, params);
-    };
-    WalletMethods.prototype.isOnline = function () {
+    }
+    isOnline() {
         return this.dataCall(types_1.RPCMethod.IsOnline);
-    };
-    WalletMethods.prototype.setOnlineMode = function (params) {
+    }
+    setOnlineMode(params) {
         return this.dataCall(types_1.RPCMethod.SetOfflineMode, params);
-    };
-    WalletMethods.prototype.setOfflineMode = function () {
+    }
+    setOfflineMode() {
         return this.dataCall(types_1.RPCMethod.SetOfflineMode);
-    };
-    WalletMethods.prototype.signData = function (data) {
+    }
+    signData(data) {
         return this.dataCall(types_1.RPCMethod.SignData, data.toObject());
-    };
-    WalletMethods.prototype.estimateFees = function (params) {
+    }
+    estimateFees(params) {
         return this.dataCall(types_1.RPCMethod.EstimateFees, params);
-    };
-    WalletMethods.prototype.estimateExtraDataSize = function (params) {
+    }
+    estimateExtraDataSize(params) {
         return this.dataCall(types_1.RPCMethod.EstimateExtraDataSize, params);
-    };
-    WalletMethods.prototype.networkInfo = function () {
+    }
+    networkInfo() {
         return this.dataCall(types_1.RPCMethod.NetworkInfo);
-    };
-    WalletMethods.prototype.decryptExtraData = function (params) {
+    }
+    decryptExtraData(params) {
         return this.dataCall(types_1.RPCMethod.DecryptExtraData, params);
-    };
-    WalletMethods.prototype.decryptCiphertext = function (params) {
+    }
+    decryptCiphertext(params) {
         return this.dataCall(types_1.RPCMethod.DecryptCiphertext, params);
-    };
-    WalletMethods.prototype.getMatchingKeys = function (params) {
+    }
+    getMatchingKeys(params) {
         return this.dataCall(types_1.RPCMethod.GetMatchingKeys, params);
-    };
-    WalletMethods.prototype.countMatchingEntries = function (params) {
+    }
+    countMatchingEntries(params) {
         return this.dataCall(types_1.RPCMethod.CountMatchingEntries, params);
-    };
-    WalletMethods.prototype.getValueFromKey = function (params) {
+    }
+    getValueFromKey(params) {
         return this.dataCall(types_1.RPCMethod.GetValueFromKey, params);
-    };
-    WalletMethods.prototype.store = function (params) {
+    }
+    store(params) {
         return this.dataCall(types_1.RPCMethod.Store, params);
-    };
-    WalletMethods.prototype["delete"] = function (params) {
+    }
+    delete(params) {
         return this.dataCall(types_1.RPCMethod.Delete, params);
-    };
-    WalletMethods.prototype.deleteTreeEntries = function (tree) {
-        return this.dataCall(types_1.RPCMethod.DeleteTreeEntries, { tree: tree });
-    };
-    WalletMethods.prototype.hasKey = function (params) {
+    }
+    deleteTreeEntries(tree) {
+        return this.dataCall(types_1.RPCMethod.DeleteTreeEntries, { tree });
+    }
+    hasKey(params) {
         return this.dataCall(types_1.RPCMethod.HasKey, params);
-    };
-    WalletMethods.prototype.queryDB = function (params) {
+    }
+    queryDB(params) {
         return this.dataCall(types_1.RPCMethod.QueryDB, params);
-    };
-    return WalletMethods;
-}());
+    }
+}
 exports.WalletMethods = WalletMethods;
-var WS = /** @class */ (function (_super) {
-    __extends(WS, _super);
-    function WS(endpoint, username, password) {
-        var _this = _super.call(this, endpoint, { auth: "".concat(username, ":").concat(password) }) || this;
-        _this.methods = new WalletMethods(_this);
-        return _this;
-    }
-    return WS;
-}(websocket_1.WSRPC));
+class WS extends websocket_1.WSRPC {
+    constructor(endpoint, username, password) {
+        super(endpoint, { auth: `${username}:${password}` });
+        this.methods = new WalletMethods(this);
+    }
+}
 exports.WS = WS;
-exports["default"] = WS;
+exports.default = WS;