@xelis/sdk 0.9.11 → 0.10.1

package/dist/cjs/address/address.js

@@ -0,0 +1,55 @@
+"use strict";
+exports.__esModule = true;
+var bech32_1 = require("./bech32");
+var value_1 = require("../data/value");
+var PrefixAddress = "xel";
+var TestnetPrefixAddress = "xet";
+var ExtraDataLimit = 1024;
+var ErrIntegratedDataLimit = "invalid data in integrated address, maximum size reached";
+var ErrInvalidNetworkPrefix = "invalid network prefix (xel or xet)";
+var Address = /** @class */ (function () {
+    function Address(data, hrp) {
+        this.isMainnet = hrp === PrefixAddress;
+        this.publicKey = data.splice(0, 32);
+        var addrType = data.splice(0, 1)[0];
+        switch (addrType) {
+            case 0:
+                this.isIntegrated = false;
+                break;
+            case 1:
+                this.isIntegrated = true;
+                var reader = new value_1.ValueReader(new Uint8Array(data));
+                this.extraData = reader.read();
+                break;
+            default:
+                throw "invalid address type";
+        }
+    }
+    Address.fromString = function (addr) {
+        var _a = (0, bech32_1.decode)(addr), hrp = _a.hrp, decoded = _a.decoded;
+        if (hrp !== PrefixAddress && hrp !== TestnetPrefixAddress) {
+            throw ErrInvalidNetworkPrefix;
+        }
+        var bits = (0, bech32_1.convertBits)(decoded, 5, 8, false);
+        return new Address(bits, hrp);
+    };
+    Address.isValid = function (addr) {
+        try {
+            Address.fromString(addr);
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    };
+    Address.prototype.format = function () {
+        var bits = (0, bech32_1.convertBits)(this.publicKey, 8, 5, true);
+        var hrp = PrefixAddress;
+        if (!this.isMainnet) {
+            hrp = TestnetPrefixAddress;
+        }
+        return (0, bech32_1.encode)(hrp, bits);
+    };
+    return Address;
+}());
+exports["default"] = Address;

package/dist/cjs/address/bech32.js

@@ -0,0 +1,167 @@
+"use strict";
+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));
+};
+exports.__esModule = true;
+exports.encode = exports.decode = exports.convertBits = void 0;
+var CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+var GENERATOR = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3];
+var SEPARTOR = ":";
+var ErrHrpMixCase = "mix case is not allowed in human readable part";
+var ErrInvalidChecksum = "invalid checksum";
+var ErrNonZeroPadding = "non zero padding";
+var ErrIllegalZeroPadding = "illegal zero padding";
+var ErrHrpEmpty = "human readable part is empty";
+function ErrSeparatorInvalidPosition(pos) {
+    return "invalid separator position: ".concat(pos);
+}
+function ErrHrpInvalidCharacter(c) {
+    return "invalid character value in human readable part: ".concat(c);
+}
+function ErrInvalidIndex(index) {
+    return "invalid index ".concat(index);
+}
+function ErrInvalidValue(value, max) {
+    return "invalid value: ".concat(value, ", max is ").concat(max);
+}
+function ErrInvalidDataRange(value, from) {
+    return "invalid data range: ".concat(value, ", max is ").concat(from);
+}
+function polymod(values) {
+    var chk = 1;
+    values.forEach(function (value) {
+        var top = chk >> 25;
+        chk = ((chk & 0x1ffffff) << 5) ^ value;
+        GENERATOR.forEach(function (item, i) {
+            if (((top >> i) & 1) === 1) {
+                chk ^= item;
+            }
+        });
+    });
+    return chk;
+}
+function hrpExpand(hrp) {
+    var encoder = new TextEncoder();
+    var bytes = encoder.encode(hrp);
+    var result = [];
+    bytes.forEach(function (c) { return result.push(c >> 5); });
+    result.push(0);
+    bytes.forEach(function (c) { return result.push(c & 31); });
+    return result;
+}
+function verifyChecksum(hrp, data) {
+    var vec = hrpExpand(hrp);
+    vec = __spreadArray(__spreadArray([], vec, true), data, true);
+    return polymod(vec) === 1;
+}
+function createChecksum(hrp, data) {
+    var result = [0, 0, 0, 0, 0, 0];
+    var values = __spreadArray(__spreadArray(__spreadArray([], hrpExpand(hrp), true), data, true), result, true);
+    var pm = polymod(values) ^ 1;
+    for (var i = 0; i < 6; i++) {
+        result[i] = pm >> (5 * (5 - i)) & 31;
+    }
+    return result;
+}
+function convertBits(data, from, to, pad) {
+    var result = [];
+    var acc = 0;
+    var bits = 0;
+    var maxValue = (1 << to) - 1;
+    data.forEach(function (value) {
+        if (value >> from !== 0) {
+            throw ErrInvalidDataRange(value, from);
+        }
+        acc = (acc << from) | value;
+        bits += from;
+        while (bits >= to) {
+            bits -= to;
+            result.push((acc >> bits) & maxValue);
+        }
+    });
+    if (pad) {
+        if (bits > 0) {
+            result.push((acc << (to - bits)) & maxValue);
+        }
+    }
+    else if (bits >= from) {
+        throw ErrIllegalZeroPadding;
+    }
+    else if (((acc << (to - bits)) & maxValue) !== 0) {
+        throw ErrNonZeroPadding;
+    }
+    return result;
+}
+exports.convertBits = convertBits;
+function decode(bech) {
+    if (bech.toUpperCase() !== bech && bech.toLowerCase() !== bech) {
+        throw ErrHrpMixCase;
+    }
+    var pos = bech.indexOf(SEPARTOR);
+    if (pos < 1 || pos + 7 > bech.length) {
+        throw ErrSeparatorInvalidPosition(pos);
+    }
+    var hrp = bech.substring(0, pos);
+    var encoder = new TextEncoder();
+    var hrpBytes = encoder.encode(hrp);
+    var decoded = [];
+    hrpBytes.forEach(function (value) {
+        if (value < 33 || value > 126) {
+            throw ErrHrpInvalidCharacter(value);
+        }
+    });
+    for (var i = pos + 1; i < bech.length; i++) {
+        if (i >= bech.length) {
+            throw ErrInvalidIndex(i);
+        }
+        var c = bech[i];
+        var index = CHARSET.indexOf(c);
+        if (index === -1) {
+            throw ErrHrpInvalidCharacter;
+        }
+        decoded.push(index);
+    }
+    if (!verifyChecksum(hrp, decoded)) {
+        throw ErrInvalidChecksum;
+    }
+    decoded.splice(decoded.length - 6, 6);
+    return { hrp: hrp, decoded: decoded };
+}
+exports.decode = decode;
+function encode(hrp, data) {
+    if (hrp.length === 0) {
+        throw ErrHrpEmpty;
+    }
+    var encoder = new TextEncoder();
+    var hrpBytes = encoder.encode(hrp);
+    hrpBytes.forEach(function (value) {
+        if (value < 33 || value > 126) {
+            throw ErrHrpInvalidCharacter(value);
+        }
+    });
+    if (hrp.toUpperCase() !== hrp && hrp.toLowerCase() !== hrp) {
+        throw ErrHrpMixCase;
+    }
+    hrp = hrp.toLowerCase();
+    var combined = __spreadArray(__spreadArray([], data, true), createChecksum(hrp, data), true);
+    var result = __spreadArray(__spreadArray([], Array.from(hrpBytes), true), [SEPARTOR.charCodeAt(0)], false);
+    combined.forEach(function (index) {
+        if (index > CHARSET.length) {
+            throw ErrInvalidValue(index, CHARSET.length);
+        }
+        var value = CHARSET.charCodeAt(index);
+        if (!value) {
+            throw ErrInvalidIndex(index);
+        }
+        result.push(value);
+    });
+    var decoder = new TextDecoder();
+    return decoder.decode(new Uint8Array(result));
+}
+exports.encode = encode;

package/dist/cjs/config.js

@@ -1,6 +1,6 @@
 "use strict";
 exports.__esModule = true;
-exports.XELIS_ASSET = exports.LOCAL_XSWD_WS = exports.LOCAL_XSWD_URL = exports.LOCAL_WALLET_WS = exports.LOCAL_WALLET_RPC = exports.LOCAL_WALLET_URL = exports.LOCAL_NODE_WS = exports.TESTNET_NODE_WS = exports.MAINNET_NODE_WS = exports.LOCAL_NODE_RPC = exports.TESTNET_NODE_RPC = exports.MAINNET_NODE_RPC = exports.LOCAL_NODE_URL = exports.TESTNET_NODE_URL = exports.MAINNET_NODE_URL = exports.XSWD_PORT = exports.WALLET_RPC_PORT = exports.DAEMON_RPC_PORT = void 0;
+exports.XELIS_DECIMALS = exports.XELIS_ASSET = exports.LOCAL_XSWD_WS = exports.LOCAL_XSWD_URL = exports.LOCAL_WALLET_WS = exports.LOCAL_WALLET_RPC = exports.LOCAL_WALLET_URL = exports.LOCAL_NODE_WS = exports.TESTNET_NODE_WS = exports.MAINNET_NODE_WS = exports.LOCAL_NODE_RPC = exports.TESTNET_NODE_RPC = exports.MAINNET_NODE_RPC = exports.LOCAL_NODE_URL = exports.TESTNET_NODE_URL = exports.MAINNET_NODE_URL = exports.XSWD_PORT = exports.WALLET_RPC_PORT = exports.DAEMON_RPC_PORT = void 0;
 exports.DAEMON_RPC_PORT = "8080";
 exports.WALLET_RPC_PORT = "8081";
 exports.XSWD_PORT = "44325";
@@ -19,6 +19,7 @@ exports.LOCAL_WALLET_WS = "ws://".concat(exports.LOCAL_WALLET_URL, "/json_rpc");
 exports.LOCAL_XSWD_URL = "127.0.0.1:".concat(exports.XSWD_PORT);
 exports.LOCAL_XSWD_WS = "ws://".concat(exports.LOCAL_XSWD_URL, "/xswd");
 exports.XELIS_ASSET = "0000000000000000000000000000000000000000000000000000000000000000";
+exports.XELIS_DECIMALS = 8;
 exports["default"] = {
     MAINNET_NODE_URL: exports.MAINNET_NODE_URL,
     TESTNET_NODE_URL: exports.TESTNET_NODE_URL,
@@ -36,5 +37,6 @@ exports["default"] = {
     LOCAL_WALLET_WS: exports.LOCAL_WALLET_WS,
     LOCAL_XSWD_URL: exports.LOCAL_XSWD_URL,
     LOCAL_XSWD_WS: exports.LOCAL_XSWD_WS,
-    XELIS_ASSET: exports.XELIS_ASSET
+    XELIS_ASSET: exports.XELIS_ASSET,
+    XELIS_DECIMALS: exports.XELIS_DECIMALS
 };

package/dist/cjs/daemon/rpc.js

@@ -17,157 +17,208 @@ var __extends = (this && this.__extends) || (function () {
 exports.__esModule = true;
 exports.RPC = void 0;
 var types_1 = require("./types");
-var rpc_1 = require("../lib/rpc");
+var http_1 = require("../rpc/http");
 var RPC = /** @class */ (function (_super) {
     __extends(RPC, _super);
     function RPC() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
     RPC.prototype.getVersion = function () {
-        return this.post(types_1.RPCMethod.GetVersion);
+        return this.request(types_1.RPCMethod.GetVersion);
     };
     RPC.prototype.getHeight = function () {
-        return this.post(types_1.RPCMethod.GetHeight);
+        return this.request(types_1.RPCMethod.GetHeight);
     };
     RPC.prototype.getTopoheight = function () {
-        return this.post(types_1.RPCMethod.GetTopoheight);
+        return this.request(types_1.RPCMethod.GetTopoheight);
+    };
+    RPC.prototype.getPrunedTopoheight = function () {
+        return this.request(types_1.RPCMethod.GetPrunedTopoheight);
+    };
+    RPC.prototype.getInfo = function () {
+        return this.request(types_1.RPCMethod.GetInfo);
+    };
+    RPC.prototype.getDifficulty = function () {
+        return this.request(types_1.RPCMethod.GetDifficulty);
+    };
+    RPC.prototype.getTips = function () {
+        return this.request(types_1.RPCMethod.GetTips);
+    };
+    RPC.prototype.getDevFeeThresholds = function () {
+        return this.request(types_1.RPCMethod.GetDevFeeThresholds);
+    };
+    RPC.prototype.getSizeOnDisk = function () {
+        return this.request(types_1.RPCMethod.GetSizeOnDisk);
     };
     RPC.prototype.getStableHeight = function () {
-        return this.post(types_1.RPCMethod.GetStableHeight);
+        return this.request(types_1.RPCMethod.GetStableHeight);
     };
     RPC.prototype.getStableTopoheight = function () {
-        return this.post(types_1.RPCMethod.GetStableTopoheight);
+        return this.request(types_1.RPCMethod.GetStableTopoheight);
     };
-    RPC.prototype.getStableBalance = function (params) {
-        return this.post(types_1.RPCMethod.GetStableBalance, params);
-    };
-    RPC.prototype.getBlockTemplate = function (address) {
-        return this.post(types_1.RPCMethod.GetBlockTemplate, { address: address });
+    RPC.prototype.getHardForks = function () {
+        return this.request(types_1.RPCMethod.GetHardForks);
     };
     RPC.prototype.getBlockAtTopoheight = function (params) {
-        return this.post(types_1.RPCMethod.GetBlockAtTopoheight, params);
+        return this.request(types_1.RPCMethod.GetBlockAtTopoheight, params);
     };
     RPC.prototype.getBlocksAtHeight = function (params) {
-        return this.post(types_1.RPCMethod.GetBlocksAtHeight, params);
+        return this.request(types_1.RPCMethod.GetBlocksAtHeight, params);
     };
     RPC.prototype.getBlockByHash = function (params) {
-        return this.post(types_1.RPCMethod.GetBlockByHash, params);
+        return this.request(types_1.RPCMethod.GetBlockByHash, params);
     };
     RPC.prototype.getTopBlock = function (params) {
-        return this.post(types_1.RPCMethod.GetTopBlock, params);
-    };
-    RPC.prototype.submitBlock = function (params) {
-        return this.post(types_1.RPCMethod.SubmitBlock, params);
+        return this.request(types_1.RPCMethod.GetTopBlock, params);
     };
     RPC.prototype.getBalance = function (params) {
-        return this.post(types_1.RPCMethod.GetBalance, params);
+        return this.request(types_1.RPCMethod.GetBalance, params);
+    };
+    RPC.prototype.getStableBalance = function (params) {
+        return this.request(types_1.RPCMethod.GetStableBalance, params);
     };
     RPC.prototype.hasBalance = function (params) {
-        return this.post(types_1.RPCMethod.HasBalance, params);
+        return this.request(types_1.RPCMethod.HasBalance, params);
     };
     RPC.prototype.getBalanceAtTopoheight = function (params) {
-        return this.post(types_1.RPCMethod.GetBalanceAtTopoheight, params);
-    };
-    RPC.prototype.getInfo = function () {
-        return this.post(types_1.RPCMethod.GetInfo);
+        return this.request(types_1.RPCMethod.GetBalanceAtTopoheight, params);
     };
     RPC.prototype.getNonce = function (params) {
-        return this.post(types_1.RPCMethod.GetNonce, params);
+        return this.request(types_1.RPCMethod.GetNonce, params);
     };
     RPC.prototype.hasNonce = function (params) {
-        return this.post(types_1.RPCMethod.HasNonce, params);
+        return this.request(types_1.RPCMethod.HasNonce, params);
     };
     RPC.prototype.getNonceAtTopoheight = function (params) {
-        return this.post(types_1.RPCMethod.GetNonceAtTopoheight, params);
+        return this.request(types_1.RPCMethod.GetNonceAtTopoheight, params);
     };
     RPC.prototype.getAsset = function (params) {
-        return this.post(types_1.RPCMethod.GetAsset, params);
+        return this.request(types_1.RPCMethod.GetAsset, params);
     };
     RPC.prototype.getAssets = function (params) {
-        return this.post(types_1.RPCMethod.GetAssets, params);
+        return this.request(types_1.RPCMethod.GetAssets, params);
     };
     RPC.prototype.countAssets = function () {
-        return this.post(types_1.RPCMethod.CountAssets);
+        return this.request(types_1.RPCMethod.CountAssets);
+    };
+    RPC.prototype.countTransactions = function () {
+        return this.request(types_1.RPCMethod.CountTransactions);
     };
     RPC.prototype.countAccounts = function () {
-        return this.post(types_1.RPCMethod.CountAccounts);
+        return this.request(types_1.RPCMethod.CountAccounts);
     };
-    RPC.prototype.countTransactions = function () {
-        return this.post(types_1.RPCMethod.CountTransactions);
+    RPC.prototype.countContracts = function () {
+        return this.request(types_1.RPCMethod.CountContracts);
     };
     RPC.prototype.submitTransaction = function (hexData) {
-        return this.post(types_1.RPCMethod.SubmitTransaction, { data: hexData });
+        return this.request(types_1.RPCMethod.SubmitTransaction, { data: hexData });
+    };
+    RPC.prototype.getTransationExecutor = function (hash) {
+        return this.request(types_1.RPCMethod.GetTransactionExecutor, { hash: hash });
     };
     RPC.prototype.getTransaction = function (hash) {
-        return this.post(types_1.RPCMethod.GetTransaction, { hash: hash });
+        return this.request(types_1.RPCMethod.GetTransaction, { hash: hash });
+    };
+    RPC.prototype.getTransactions = function (txHashes) {
+        return this.request(types_1.RPCMethod.GetTransactions, { tx_hashes: txHashes });
+    };
+    RPC.prototype.isTxExecutedInBlock = function (params) {
+        return this.request(types_1.RPCMethod.IsTxExecutedInBlock, params);
     };
     RPC.prototype.p2pStatus = function () {
-        return this.post(types_1.RPCMethod.P2PStatus);
+        return this.request(types_1.RPCMethod.P2PStatus);
     };
     RPC.prototype.getPeers = function () {
-        return this.post(types_1.RPCMethod.GetPeers);
+        return this.request(types_1.RPCMethod.GetPeers);
     };
     RPC.prototype.getMemPool = function () {
-        return this.post(types_1.RPCMethod.GetMempool);
+        return this.request(types_1.RPCMethod.GetMempool);
     };
-    RPC.prototype.getTips = function () {
-        return this.post(types_1.RPCMethod.GetTips);
+    RPC.prototype.getMempoolCache = function (address) {
+        return this.request(types_1.RPCMethod.GetMempoolCache, { address: address });
+    };
+    RPC.prototype.getEstimatedFeeRates = function () {
+        return this.request(types_1.RPCMethod.GetEstimatedFeeRates);
     };
     RPC.prototype.getDAGOrder = function (params) {
-        return this.post(types_1.RPCMethod.GetDAGOrder, params);
+        return this.request(types_1.RPCMethod.GetDAGOrder, params);
     };
     RPC.prototype.getBlocksRangeByTopoheight = function (params) {
-        return this.post(types_1.RPCMethod.GetBlocksRangeByTopoheight, params);
+        return this.request(types_1.RPCMethod.GetBlocksRangeByTopoheight, params);
     };
     RPC.prototype.getBlocksRangeByHeight = function (params) {
-        return this.post(types_1.RPCMethod.GetBlocksRangeByHeight, params);
-    };
-    RPC.prototype.getTransactions = function (txHashes) {
-        return this.post(types_1.RPCMethod.GetTransactions, { tx_hashes: txHashes });
+        return this.request(types_1.RPCMethod.GetBlocksRangeByHeight, params);
     };
     RPC.prototype.getAccountHistory = function (params) {
-        return this.post(types_1.RPCMethod.GetAccountHistory, params);
+        return this.request(types_1.RPCMethod.GetAccountHistory, params);
     };
     RPC.prototype.getAccountAssets = function (address) {
-        return this.post(types_1.RPCMethod.GetAccountAssets, { address: address });
+        return this.request(types_1.RPCMethod.GetAccountAssets, { address: address });
     };
     RPC.prototype.getAccounts = function (params) {
-        return this.post(types_1.RPCMethod.GetAccounts, params);
+        return this.request(types_1.RPCMethod.GetAccounts, params);
     };
-    RPC.prototype.isTxExecutedInBlock = function (params) {
-        return this.post(types_1.RPCMethod.IsTxExecutedInBlock, params);
+    RPC.prototype.isAccountRegistered = function (params) {
+        return this.request(types_1.RPCMethod.IsAccountRegistered, params);
     };
-    RPC.prototype.getDevFeeThresholds = function () {
-        return this.post(types_1.RPCMethod.GetDevFeeThresholds);
+    RPC.prototype.getAccountRegistrationTopoheight = function (address) {
+        return this.request(types_1.RPCMethod.GetAccountRegistrationTopoheight, { address: address });
     };
-    RPC.prototype.getSizeOnDisk = function () {
-        return this.post(types_1.RPCMethod.GetSizeOnDisk);
+    RPC.prototype.validateAddress = function (params) {
+        return this.request(types_1.RPCMethod.ValidateAddress, params);
     };
-    RPC.prototype.getAccountRegistrationTopoheight = function (address) {
-        return this.post(types_1.RPCMethod.GetAccountRegistrationTopoheight, { address: address });
+    RPC.prototype.splitAddress = function (params) {
+        return this.request(types_1.RPCMethod.SplitAddress, params);
     };
-    RPC.prototype.isAccountRegistered = function (params) {
-        return this.post(types_1.RPCMethod.IsAccountRegistered, params);
+    RPC.prototype.extractKeyFromAddress = function (params) {
+        return this.request(types_1.RPCMethod.ExtractKeyFromAddress, params);
     };
-    RPC.prototype.getMempoolCache = function (address) {
-        return this.post(types_1.RPCMethod.GetMempoolCache, { address: address });
+    RPC.prototype.makeIntegratedAddress = function (params) {
+        return this.request(types_1.RPCMethod.MakeIntegratedAddress, params);
     };
-    RPC.prototype.getDifficulty = function () {
-        return this.post(types_1.RPCMethod.GetDifficulty);
+    RPC.prototype.decryptExtraData = function (params) {
+        return this.request(types_1.RPCMethod.DecryptExtraData, params);
     };
-    RPC.prototype.validateAddress = function (params) {
-        return this.post(types_1.RPCMethod.ValidateAddress, params);
+    RPC.prototype.getMultisigAtTopoheight = function (params) {
+        return this.request(types_1.RPCMethod.GetMultisigAtTopoheight, params);
     };
-    RPC.prototype.extractKeyFromAddress = function (params) {
-        return this.post(types_1.RPCMethod.ExtractKeyFromAddress, params);
+    RPC.prototype.getMultisig = function (params) {
+        return this.request(types_1.RPCMethod.GetMultisig, params);
+    };
+    RPC.prototype.hasMultisig = function (params) {
+        return this.request(types_1.RPCMethod.HasMultisig, params);
+    };
+    RPC.prototype.hasMultisigAtTopoheight = function (params) {
+        return this.request(types_1.RPCMethod.HasMultisigAtTopoheight, params);
+    };
+    RPC.prototype.getContractOutputs = function (params) {
+        return this.request(types_1.RPCMethod.GetContractOutputs, params);
+    };
+    RPC.prototype.getContractModule = function (params) {
+        return this.request(types_1.RPCMethod.GetContractModule, params);
+    };
+    RPC.prototype.getContractData = function (params) {
+        return this.request(types_1.RPCMethod.GetContractData, params);
+    };
+    RPC.prototype.getContractDataAtTopoheight = function (params) {
+        return this.request(types_1.RPCMethod.GetContractDataAtTopoheight, params);
+    };
+    RPC.prototype.getContractBalance = function (params) {
+        return this.request(types_1.RPCMethod.GetContractBalance, params);
+    };
+    RPC.prototype.getContractBalanceAtTopoheight = function (params) {
+        return this.request(types_1.RPCMethod.GetContractBalanceAtTopoheight, params);
+    };
+    RPC.prototype.getBlockTemplate = function (address) {
+        return this.request(types_1.RPCMethod.GetBlockTemplate, { address: address });
     };
     RPC.prototype.getMinerWork = function (params) {
-        return this.post(types_1.RPCMethod.GetMinerWork, params);
+        return this.request(types_1.RPCMethod.GetMinerWork, params);
     };
-    RPC.prototype.splitAddress = function (params) {
-        return this.post(types_1.RPCMethod.SplitAddress, params);
+    RPC.prototype.submitBlock = function (params) {
+        return this.request(types_1.RPCMethod.SubmitBlock, params);
     };
     return RPC;
-}(rpc_1.RPC));
+}(http_1.HttpRPC));
 exports.RPC = RPC;
 exports["default"] = RPC;

package/dist/cjs/daemon/types.js

@@ -17,53 +17,70 @@ var BlockType;
 var RPCMethod;
 (function (RPCMethod) {
     RPCMethod["GetVersion"] = "get_version";
-    RPCMethod["GetInfo"] = "get_info";
     RPCMethod["GetHeight"] = "get_height";
     RPCMethod["GetTopoheight"] = "get_topoheight";
+    RPCMethod["GetPrunedTopoheight"] = "get_pruned_topoheight";
+    RPCMethod["GetInfo"] = "get_info";
+    RPCMethod["GetDifficulty"] = "get_difficulty";
+    RPCMethod["GetTips"] = "get_tips";
+    RPCMethod["GetDevFeeThresholds"] = "get_dev_fee_thresholds";
+    RPCMethod["GetSizeOnDisk"] = "get_size_on_disk";
     RPCMethod["GetStableHeight"] = "get_stable_height";
     RPCMethod["GetStableTopoheight"] = "get_stable_topoheight";
-    RPCMethod["GetStableBalance"] = "get_stable_balance";
-    RPCMethod["GetBlockTemplate"] = "get_block_template";
+    RPCMethod["GetHardForks"] = "get_hard_forks";
     RPCMethod["GetBlockAtTopoheight"] = "get_block_at_topoheight";
     RPCMethod["GetBlocksAtHeight"] = "get_blocks_at_height";
     RPCMethod["GetBlockByHash"] = "get_block_by_hash";
     RPCMethod["GetTopBlock"] = "get_top_block";
-    RPCMethod["GetNonce"] = "get_nonce";
-    RPCMethod["GetNonceAtTopoheight"] = "get_nonce_at_topoheight";
-    RPCMethod["HasNonce"] = "has_nonce";
     RPCMethod["GetBalance"] = "get_balance";
+    RPCMethod["GetStableBalance"] = "get_stable_balance";
     RPCMethod["HasBalance"] = "has_balance";
     RPCMethod["GetBalanceAtTopoheight"] = "get_balance_at_topoheight";
+    RPCMethod["GetNonce"] = "get_nonce";
+    RPCMethod["HasNonce"] = "has_nonce";
+    RPCMethod["GetNonceAtTopoheight"] = "get_nonce_at_topoheight";
     RPCMethod["GetAsset"] = "get_asset";
     RPCMethod["GetAssets"] = "get_assets";
     RPCMethod["CountAssets"] = "count_assets";
     RPCMethod["CountTransactions"] = "count_transactions";
-    RPCMethod["GetTips"] = "get_tips";
-    RPCMethod["P2PStatus"] = "p2p_status";
-    RPCMethod["GetDAGOrder"] = "get_dag_order";
-    RPCMethod["GetMempool"] = "get_mempool";
+    RPCMethod["CountAccounts"] = "count_accounts";
+    RPCMethod["CountContracts"] = "count_contracts";
+    RPCMethod["SubmitTransaction"] = "submit_transaction";
+    RPCMethod["GetTransactionExecutor"] = "get_transaction_executor";
     RPCMethod["GetTransaction"] = "get_transaction";
     RPCMethod["GetTransactions"] = "get_transactions";
+    RPCMethod["IsTxExecutedInBlock"] = "is_tx_executed_in_block";
+    RPCMethod["P2PStatus"] = "p2p_status";
+    RPCMethod["GetPeers"] = "get_peers";
+    RPCMethod["GetMempool"] = "get_mempool";
+    RPCMethod["GetMempoolCache"] = "get_mempool_cache";
+    RPCMethod["GetEstimatedFeeRates"] = "get_estimated_fee_rates";
+    RPCMethod["GetDAGOrder"] = "get_dag_order";
     RPCMethod["GetBlocksRangeByTopoheight"] = "get_blocks_range_by_topoheight";
     RPCMethod["GetBlocksRangeByHeight"] = "get_blocks_range_by_height";
-    RPCMethod["GetAccounts"] = "get_accounts";
-    RPCMethod["SubmitBlock"] = "submit_block";
-    RPCMethod["SubmitTransaction"] = "submit_transaction";
-    RPCMethod["CountAccounts"] = "count_accounts";
     RPCMethod["GetAccountHistory"] = "get_account_history";
     RPCMethod["GetAccountAssets"] = "get_account_assets";
-    RPCMethod["GetPeers"] = "get_peers";
-    RPCMethod["GetDevFeeThresholds"] = "get_dev_fee_thresholds";
-    RPCMethod["GetSizeOnDisk"] = "get_size_on_disk";
-    RPCMethod["IsTxExecutedInBlock"] = "is_tx_executed_in_block";
-    RPCMethod["GetAccountRegistrationTopoheight"] = "get_account_registration_topoheight";
+    RPCMethod["GetAccounts"] = "get_accounts";
     RPCMethod["IsAccountRegistered"] = "is_account_registered";
-    RPCMethod["GetMempoolCache"] = "get_mempool_cache";
-    RPCMethod["GetDifficulty"] = "get_difficulty";
+    RPCMethod["GetAccountRegistrationTopoheight"] = "get_account_registration_topoheight";
     RPCMethod["ValidateAddress"] = "validate_address";
+    RPCMethod["SplitAddress"] = "split_address";
     RPCMethod["ExtractKeyFromAddress"] = "extract_key_from_address";
+    RPCMethod["MakeIntegratedAddress"] = "make_integrated_address";
+    RPCMethod["DecryptExtraData"] = "decrypt_extra_data";
+    RPCMethod["GetMultisigAtTopoheight"] = "get_multisig_at_topoheight";
+    RPCMethod["GetMultisig"] = "get_multisig";
+    RPCMethod["HasMultisig"] = "has_multisig";
+    RPCMethod["HasMultisigAtTopoheight"] = "has_multisig_at_topoheight";
+    RPCMethod["GetContractOutputs"] = "get_contract_outputs";
+    RPCMethod["GetContractModule"] = "get_contract_module";
+    RPCMethod["GetContractData"] = "get_contract_data";
+    RPCMethod["GetContractDataAtTopoheight"] = "get_contract_data_at_topoheight";
+    RPCMethod["GetContractBalance"] = "get_contract_balance";
+    RPCMethod["GetContractBalanceAtTopoheight"] = "get_contract_balance_at_topoheight";
+    RPCMethod["GetBlockTemplate"] = "get_block_template";
     RPCMethod["GetMinerWork"] = "get_miner_work";
-    RPCMethod["SplitAddress"] = "split_address";
+    RPCMethod["SubmitBlock"] = "submit_block";
 })(RPCMethod = exports.RPCMethod || (exports.RPCMethod = {}));
 var RPCEvent;
 (function (RPCEvent) {
@@ -71,14 +88,17 @@ var RPCEvent;
     RPCEvent["BlockOrdered"] = "block_ordered";
     RPCEvent["BlockOrphaned"] = "block_orphaned";
     RPCEvent["StableHeightChanged"] = "stable_height_changed";
+    RPCEvent["StableTopoHeightChanged"] = "stable_topo_height_changed";
     RPCEvent["TransactionOrphaned"] = "transaction_orphaned";
     RPCEvent["TransactionAddedInMempool"] = "transaction_added_in_mempool";
     RPCEvent["TransactionExecuted"] = "transaction_executed";
-    RPCEvent["TransactionSCResult"] = "transaction_sc_result";
+    RPCEvent["InvokeContract"] = "invoke_contract";
+    RPCEvent["DeployContract"] = "deploy_contract";
     RPCEvent["NewAsset"] = "new_asset";
     RPCEvent["PeerConnected"] = "peer_connected";
     RPCEvent["PeerDisconnected"] = "peer_disconnected";
-    RPCEvent["PeerPeerListUpdated"] = "peer_peer_list_updated";
     RPCEvent["PeerStateUpdated"] = "peer_state_updated";
+    RPCEvent["PeerPeerListUpdated"] = "peer_peer_list_updated";
     RPCEvent["PeerPeerDisconnected"] = "peer_peer_disconnected";
+    RPCEvent["NewBlockTemplate"] = "new_block_template";
 })(RPCEvent = exports.RPCEvent || (exports.RPCEvent = {}));