@xelis/sdk 0.11.14 → 0.11.16

package/dist/cjs/daemon/websocket.js

@@ -1,253 +1,242 @@
 "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.DaemonMethods = void 0;
-var types_1 = require("./types");
-var websocket_1 = require("../rpc/websocket");
-var DaemonMethods = /** @class */ (function () {
-    function DaemonMethods(ws, prefix) {
-        if (prefix === void 0) { prefix = ""; }
+const types_1 = require("./types");
+const websocket_1 = require("../rpc/websocket");
+class DaemonMethods {
+    constructor(ws, prefix = "") {
         this.ws = ws;
         this.prefix = prefix;
     }
-    DaemonMethods.prototype.dataCall = function (method, params) {
+    dataCall(method, params) {
         return this.ws.dataCall(this.prefix + method, params);
-    };
-    DaemonMethods.prototype.closeListener = function (event, listener) {
+    }
+    closeListener(event, listener) {
         this.ws.closeListener(event, listener);
-    };
-    DaemonMethods.prototype.listen = function (event, listener) {
+    }
+    listen(event, listener) {
         this.ws.listen(this.prefix + event, listener);
-    };
-    DaemonMethods.prototype.getVersion = function () {
+    }
+    getVersion() {
         return this.dataCall(types_1.RPCMethod.GetVersion);
-    };
-    DaemonMethods.prototype.getHeight = function () {
+    }
+    getHeight() {
         return this.dataCall(types_1.RPCMethod.GetHeight);
-    };
-    DaemonMethods.prototype.getTopoheight = function () {
+    }
+    getTopoheight() {
         return this.dataCall(types_1.RPCMethod.GetTopoheight);
-    };
-    DaemonMethods.prototype.getPrunedTopoheight = function () {
+    }
+    getPrunedTopoheight() {
         return this.dataCall(types_1.RPCMethod.GetPrunedTopoheight);
-    };
-    DaemonMethods.prototype.getInfo = function () {
+    }
+    getInfo() {
         return this.dataCall(types_1.RPCMethod.GetInfo);
-    };
-    DaemonMethods.prototype.getDifficulty = function () {
+    }
+    getDifficulty() {
         return this.dataCall(types_1.RPCMethod.GetDifficulty);
-    };
-    DaemonMethods.prototype.getTips = function () {
+    }
+    getTips() {
         return this.dataCall(types_1.RPCMethod.GetTips);
-    };
-    DaemonMethods.prototype.getDevFeeThresholds = function () {
+    }
+    getDevFeeThresholds() {
         return this.dataCall(types_1.RPCMethod.GetDevFeeThresholds);
-    };
-    DaemonMethods.prototype.getSizeOnDisk = function () {
+    }
+    getSizeOnDisk() {
         return this.dataCall(types_1.RPCMethod.GetSizeOnDisk);
-    };
-    DaemonMethods.prototype.getStableHeight = function () {
+    }
+    getStableHeight() {
         return this.dataCall(types_1.RPCMethod.GetStableHeight);
-    };
-    DaemonMethods.prototype.getStableTopoheight = function () {
+    }
+    getStableTopoheight() {
         return this.dataCall(types_1.RPCMethod.GetStableTopoheight);
-    };
-    DaemonMethods.prototype.getHardForks = function () {
+    }
+    getHardForks() {
         return this.dataCall(types_1.RPCMethod.GetHardForks);
-    };
-    DaemonMethods.prototype.getBlockAtTopoheight = function (params) {
+    }
+    getBlockAtTopoheight(params) {
         return this.dataCall(types_1.RPCMethod.GetBlockAtTopoheight, params);
-    };
-    DaemonMethods.prototype.getBlocksAtHeight = function (params) {
+    }
+    getBlocksAtHeight(params) {
         return this.dataCall(types_1.RPCMethod.GetBlocksAtHeight, params);
-    };
-    DaemonMethods.prototype.getBlockByHash = function (params) {
+    }
+    getBlockByHash(params) {
         return this.dataCall(types_1.RPCMethod.GetBlockByHash, params);
-    };
-    DaemonMethods.prototype.getTopBlock = function (params) {
+    }
+    getTopBlock(params) {
         return this.dataCall(types_1.RPCMethod.GetTopBlock, params);
-    };
-    DaemonMethods.prototype.getBalance = function (params) {
+    }
+    getBalance(params) {
         return this.dataCall(types_1.RPCMethod.GetBalance, params);
-    };
-    DaemonMethods.prototype.getStableBalance = function (params) {
+    }
+    getStableBalance(params) {
         return this.dataCall(types_1.RPCMethod.GetStableBalance, params);
-    };
-    DaemonMethods.prototype.hasBalance = function (params) {
+    }
+    hasBalance(params) {
         return this.dataCall(types_1.RPCMethod.HasBalance, params);
-    };
-    DaemonMethods.prototype.getBalanceAtTopoheight = function (params) {
+    }
+    getBalanceAtTopoheight(params) {
         return this.dataCall(types_1.RPCMethod.GetBalanceAtTopoheight, params);
-    };
-    DaemonMethods.prototype.getNonce = function (params) {
+    }
+    getNonce(params) {
         return this.dataCall(types_1.RPCMethod.GetNonce, params);
-    };
-    DaemonMethods.prototype.hasNonce = function (params) {
+    }
+    hasNonce(params) {
         return this.dataCall(types_1.RPCMethod.HasNonce, params);
-    };
-    DaemonMethods.prototype.getNonceAtTopoheight = function (params) {
+    }
+    getNonceAtTopoheight(params) {
         return this.dataCall(types_1.RPCMethod.GetNonceAtTopoheight, params);
-    };
-    DaemonMethods.prototype.getAsset = function (params) {
+    }
+    getAsset(params) {
         return this.dataCall(types_1.RPCMethod.GetAsset, params);
-    };
-    DaemonMethods.prototype.getAssets = function (params) {
+    }
+    getAssets(params) {
         return this.dataCall(types_1.RPCMethod.GetAssets, params);
-    };
-    DaemonMethods.prototype.countAssets = function () {
+    }
+    countAssets() {
         return this.dataCall(types_1.RPCMethod.CountAssets);
-    };
-    DaemonMethods.prototype.countTransactions = function () {
+    }
+    countTransactions() {
         return this.dataCall(types_1.RPCMethod.CountTransactions);
-    };
-    DaemonMethods.prototype.countAccounts = function () {
+    }
+    countAccounts() {
         return this.dataCall(types_1.RPCMethod.CountAccounts);
-    };
-    DaemonMethods.prototype.countContracts = function () {
+    }
+    countContracts() {
         return this.dataCall(types_1.RPCMethod.CountContracts);
-    };
-    DaemonMethods.prototype.submitTransaction = function (hexData) {
+    }
+    submitTransaction(hexData) {
         return this.dataCall(types_1.RPCMethod.SubmitTransaction, { data: hexData });
-    };
-    DaemonMethods.prototype.getTransactionExecutor = function (hash) {
-        return this.dataCall(types_1.RPCMethod.GetTransactionExecutor, { hash: hash });
-    };
-    DaemonMethods.prototype.getTransaction = function (hash) {
-        return this.dataCall(types_1.RPCMethod.GetTransaction, { hash: hash });
-    };
-    DaemonMethods.prototype.getTransactions = function (txHashes) {
+    }
+    getTransactionExecutor(hash) {
+        return this.dataCall(types_1.RPCMethod.GetTransactionExecutor, { hash });
+    }
+    getTransaction(hash) {
+        return this.dataCall(types_1.RPCMethod.GetTransaction, { hash });
+    }
+    getTransactions(txHashes) {
         return this.dataCall(types_1.RPCMethod.GetTransactions, { tx_hashes: txHashes });
-    };
-    DaemonMethods.prototype.isTxExecutedInBlock = function (params) {
+    }
+    isTxExecutedInBlock(params) {
         return this.dataCall(types_1.RPCMethod.IsTxExecutedInBlock, params);
-    };
-    DaemonMethods.prototype.p2pStatus = function () {
+    }
+    p2pStatus() {
         return this.dataCall(types_1.RPCMethod.P2PStatus);
-    };
-    DaemonMethods.prototype.getPeers = function () {
+    }
+    getPeers() {
         return this.dataCall(types_1.RPCMethod.GetPeers);
-    };
-    DaemonMethods.prototype.getMemPool = function (params) {
+    }
+    getMemPool(params) {
         return this.dataCall(types_1.RPCMethod.GetMempool, params);
-    };
-    DaemonMethods.prototype.getMempoolSummary = function (params) {
+    }
+    getMempoolSummary(params) {
         return this.dataCall(types_1.RPCMethod.GetMempoolSummary, params);
-    };
-    DaemonMethods.prototype.getMempoolCache = function (address) {
-        return this.dataCall(types_1.RPCMethod.GetMempoolCache, { address: address });
-    };
-    DaemonMethods.prototype.getEstimatedFeeRates = function () {
+    }
+    getMempoolCache(address) {
+        return this.dataCall(types_1.RPCMethod.GetMempoolCache, { address });
+    }
+    getEstimatedFeeRates() {
         return this.dataCall(types_1.RPCMethod.GetEstimatedFeeRates);
-    };
-    DaemonMethods.prototype.getDAGOrder = function (params) {
+    }
+    getDAGOrder(params) {
         return this.dataCall(types_1.RPCMethod.GetDAGOrder, params);
-    };
-    DaemonMethods.prototype.getBlocksRangeByTopoheight = function (params) {
+    }
+    getBlocksRangeByTopoheight(params) {
         return this.dataCall(types_1.RPCMethod.GetBlocksRangeByTopoheight, params);
-    };
-    DaemonMethods.prototype.getBlocksRangeByHeight = function (params) {
+    }
+    getBlocksRangeByHeight(params) {
         return this.dataCall(types_1.RPCMethod.GetBlocksRangeByHeight, params);
-    };
-    DaemonMethods.prototype.getAccountHistory = function (params) {
+    }
+    getAccountHistory(params) {
         return this.dataCall(types_1.RPCMethod.GetAccountHistory, params);
-    };
-    DaemonMethods.prototype.getAccountAssets = function (address) {
-        return this.dataCall(types_1.RPCMethod.GetAccountAssets, { address: address });
-    };
-    DaemonMethods.prototype.getAccounts = function (params) {
+    }
+    getAccountAssets(address) {
+        return this.dataCall(types_1.RPCMethod.GetAccountAssets, { address });
+    }
+    getAccounts(params) {
         return this.dataCall(types_1.RPCMethod.GetAccounts, params);
-    };
-    DaemonMethods.prototype.isAccountRegistered = function (params) {
+    }
+    isAccountRegistered(params) {
         return this.dataCall(types_1.RPCMethod.IsAccountRegistered, params);
-    };
-    DaemonMethods.prototype.getAccountRegistrationTopoheight = function (address) {
-        return this.dataCall(types_1.RPCMethod.GetAccountRegistrationTopoheight, { address: address });
-    };
-    DaemonMethods.prototype.validateAddress = function (params) {
+    }
+    getAccountRegistrationTopoheight(address) {
+        return this.dataCall(types_1.RPCMethod.GetAccountRegistrationTopoheight, { address });
+    }
+    validateAddress(params) {
         return this.dataCall(types_1.RPCMethod.ValidateAddress, params);
-    };
-    DaemonMethods.prototype.splitAddress = function (params) {
+    }
+    splitAddress(params) {
         return this.dataCall(types_1.RPCMethod.SplitAddress, params);
-    };
-    DaemonMethods.prototype.extractKeyFromAddress = function (params) {
+    }
+    extractKeyFromAddress(params) {
         return this.dataCall(types_1.RPCMethod.ExtractKeyFromAddress, params);
-    };
-    DaemonMethods.prototype.makeIntegratedAddress = function (params) {
+    }
+    makeIntegratedAddress(params) {
         return this.dataCall(types_1.RPCMethod.MakeIntegratedAddress, params);
-    };
-    DaemonMethods.prototype.decryptExtraData = function (params) {
+    }
+    decryptExtraData(params) {
         return this.dataCall(types_1.RPCMethod.DecryptExtraData, params);
-    };
-    DaemonMethods.prototype.getMultisigAtTopoheight = function (params) {
+    }
+    getMultisigAtTopoheight(params) {
         return this.dataCall(types_1.RPCMethod.GetMultisigAtTopoheight, params);
-    };
-    DaemonMethods.prototype.getMultisig = function (params) {
+    }
+    getMultisig(params) {
         return this.dataCall(types_1.RPCMethod.GetMultisig, params);
-    };
-    DaemonMethods.prototype.hasMultisig = function (params) {
+    }
+    hasMultisig(params) {
         return this.dataCall(types_1.RPCMethod.HasMultisig, params);
-    };
-    DaemonMethods.prototype.hasMultisigAtTopoheight = function (params) {
+    }
+    hasMultisigAtTopoheight(params) {
         return this.dataCall(types_1.RPCMethod.HasMultisigAtTopoheight, params);
-    };
-    DaemonMethods.prototype.getContractOutputs = function (params) {
+    }
+    getContractLogs(params) {
+        return this.dataCall(types_1.RPCMethod.GetContractLogs, params);
+    }
+    getContractScheduledExecutionsAtTopoheight(params) {
+        return this.dataCall(types_1.RPCMethod.GetContractScheduledExecutionsAtTopoheight, params);
+    }
+    getContractRegisteredExecutionsAtTopoheight(params) {
+        return this.dataCall(types_1.RPCMethod.GetContractRegisteredExecutionsAtTopoheight, params);
+    }
+    getContractOutputs(params) {
         return this.dataCall(types_1.RPCMethod.GetContractOutputs, params);
-    };
-    DaemonMethods.prototype.getContractModule = function (params) {
+    }
+    getContractModule(params) {
         return this.dataCall(types_1.RPCMethod.GetContractModule, params);
-    };
-    DaemonMethods.prototype.getContractData = function (params) {
+    }
+    getContractData(params) {
         return this.dataCall(types_1.RPCMethod.GetContractData, params);
-    };
-    DaemonMethods.prototype.getContractDataAtTopoheight = function (params) {
+    }
+    getContractDataAtTopoheight(params) {
         return this.dataCall(types_1.RPCMethod.GetContractDataAtTopoheight, params);
-    };
-    DaemonMethods.prototype.getContractBalance = function (params) {
+    }
+    getContractBalance(params) {
         return this.dataCall(types_1.RPCMethod.GetContractBalance, params);
-    };
-    DaemonMethods.prototype.getContractBalanceAtTopoheight = function (params) {
+    }
+    getContractBalanceAtTopoheight(params) {
         return this.dataCall(types_1.RPCMethod.GetContractBalanceAtTopoheight, params);
-    };
-    DaemonMethods.prototype.getContractAssets = function (params) {
+    }
+    getContractAssets(params) {
         return this.dataCall(types_1.RPCMethod.GetContractAssets, params);
-    };
-    DaemonMethods.prototype.getP2PBlockPropagation = function (params) {
+    }
+    getP2PBlockPropagation(params) {
         return this.dataCall(types_1.RPCMethod.GetP2PBlockPropagation, params);
-    };
-    DaemonMethods.prototype.getBlockTemplate = function (address) {
-        return this.dataCall(types_1.RPCMethod.GetBlockTemplate, { address: address });
-    };
-    DaemonMethods.prototype.getMinerWork = function (params) {
+    }
+    getBlockTemplate(address) {
+        return this.dataCall(types_1.RPCMethod.GetBlockTemplate, { address });
+    }
+    getMinerWork(params) {
         return this.dataCall(types_1.RPCMethod.GetMinerWork, params);
-    };
-    DaemonMethods.prototype.submitBlock = function (params) {
+    }
+    submitBlock(params) {
         return this.dataCall(types_1.RPCMethod.SubmitBlock, params);
-    };
-    return DaemonMethods;
-}());
+    }
+}
 exports.DaemonMethods = DaemonMethods;
-var WS = /** @class */ (function (_super) {
-    __extends(WS, _super);
-    function WS(endpoint) {
-        var _this = _super.call(this, endpoint) || this;
-        _this.methods = new DaemonMethods(_this);
-        return _this;
-    }
-    return WS;
-}(websocket_1.WSRPC));
+class WS extends websocket_1.WSRPC {
+    constructor(endpoint) {
+        super(endpoint);
+        this.methods = new DaemonMethods(this);
+    }
+}
 exports.WS = WS;
-exports["default"] = WS;
+exports.default = WS;

package/dist/cjs/data/element.js

@@ -1,39 +1,38 @@
 "use strict";
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.Element = exports.ElementType = void 0;
-var value_1 = require("./value");
+const value_1 = require("./value");
 var ElementType;
 (function (ElementType) {
     ElementType[ElementType["Value"] = 0] = "Value";
     ElementType[ElementType["Array"] = 1] = "Array";
     ElementType[ElementType["Fields"] = 2] = "Fields";
 })(ElementType = exports.ElementType || (exports.ElementType = {}));
-var Element = /** @class */ (function () {
-    function Element() {
-    }
-    Element.v = function (data) {
-        var element = new Element();
-        element.value = value_1.Value["new"](data);
+class Element {
+    constructor() { }
+    static v(data) {
+        let element = new Element();
+        element.value = value_1.Value.new(data);
         return element;
-    };
-    Element.value = function (value) {
-        var element = new Element();
+    }
+    static value(value) {
+        let element = new Element();
         element.value = value;
         return element;
-    };
-    Element.array = function (arr) {
-        var element = new Element();
+    }
+    static array(arr) {
+        let element = new Element();
         element.array = arr;
         return element;
-    };
-    Element.fields = function (fields) {
-        var element = new Element();
+    }
+    static fields(fields) {
+        let element = new Element();
         element.fields = fields;
         return element;
-    };
-    Element.prototype.validate = function () {
-        var count = 0;
-        var eType = 0;
+    }
+    validate() {
+        let count = 0;
+        let eType = 0;
         if (this.value) {
             count++;
             eType = ElementType.Value;
@@ -50,35 +49,34 @@ var Element = /** @class */ (function () {
             throw "only one field (Value, Array, or Fields) must be set";
         }
         return eType;
-    };
-    Element.fromBytes = function (data) {
-        var reader = new value_1.ValueReader(data);
+    }
+    static fromBytes(data) {
+        let reader = new value_1.ValueReader(data);
         return reader.read();
-    };
-    Element.prototype.toBytes = function () {
-        var writer = new value_1.ValueWriter();
+    }
+    toBytes() {
+        let writer = new value_1.ValueWriter();
         writer.write(this);
         return new Uint8Array(writer.data);
-    };
-    Element.prototype.toObject = function () {
-        var vType = this.validate();
+    }
+    toObject() {
+        let vType = this.validate();
         switch (vType) {
             case ElementType.Value:
                 return this.value.data;
             case ElementType.Array:
-                var arr_1 = [];
-                this.array.forEach(function (item) {
-                    arr_1.push(item.toObject());
+                let arr = [];
+                this.array.forEach((item) => {
+                    arr.push(item.toObject());
                 });
-                return arr_1;
+                return arr;
             case ElementType.Fields:
-                var obj_1 = {};
-                this.fields.forEach(function (item, key) {
-                    obj_1[key.data] = item.toObject();
+                let obj = {};
+                this.fields.forEach((item, key) => {
+                    obj[key.data] = item.toObject();
                 });
-                return obj_1;
+                return obj;
         }
-    };
-    return Element;
-}());
+    }
+}
 exports.Element = Element;