@xelis/sdk 0.9.11 → 0.10.1

package/dist/cjs/wallet/websocket.js

@@ -16,7 +16,7 @@ var __extends = (this && this.__extends) || (function () {
 })();
 exports.__esModule = true;
 exports.WS = exports.WalletMethods = void 0;
-var websocket_1 = require("../lib/websocket");
+var websocket_1 = require("../rpc/websocket");
 var types_1 = require("./types");
 var WalletMethods = /** @class */ (function () {
     function WalletMethods(ws, prefix) {
@@ -28,25 +28,28 @@ var WalletMethods = /** @class */ (function () {
         return this.ws.dataCall(this.prefix + method, params);
     };
     WalletMethods.prototype.onNewTopoheight = function (onData) {
-        return this.ws.listenEvent(types_1.RPCEvent.NewTopoheight, onData);
+        return this.ws.listenEvent(this.prefix + types_1.RPCEvent.NewTopoheight, onData);
     };
     WalletMethods.prototype.onNewAsset = function (onData) {
-        return this.ws.listenEvent(types_1.RPCEvent.NewAsset, onData);
+        return this.ws.listenEvent(this.prefix + types_1.RPCEvent.NewAsset, onData);
     };
     WalletMethods.prototype.onNewTransaction = function (onData) {
-        return this.ws.listenEvent(types_1.RPCEvent.NewTransaction, onData);
+        return this.ws.listenEvent(this.prefix + types_1.RPCEvent.NewTransaction, onData);
     };
     WalletMethods.prototype.onBalanceChanged = function (onData) {
-        return this.ws.listenEvent(types_1.RPCEvent.BalanceChanged, onData);
+        return this.ws.listenEvent(this.prefix + types_1.RPCEvent.BalanceChanged, onData);
     };
     WalletMethods.prototype.onRescan = function (onData) {
-        return this.ws.listenEvent(types_1.RPCEvent.Rescan, onData);
+        return this.ws.listenEvent(this.prefix + types_1.RPCEvent.Rescan, onData);
+    };
+    WalletMethods.prototype.onHistorySynced = function (onData) {
+        return this.ws.listenEvent(this.prefix + types_1.RPCEvent.HistorySynced, onData);
     };
     WalletMethods.prototype.onOnline = function (onData) {
-        return this.ws.listenEvent(types_1.RPCEvent.Online, onData);
+        return this.ws.listenEvent(this.prefix + types_1.RPCEvent.Online, onData);
     };
     WalletMethods.prototype.onOffline = function (onData) {
-        return this.ws.listenEvent(types_1.RPCEvent.Offline, onData);
+        return this.ws.listenEvent(this.prefix + types_1.RPCEvent.Offline, onData);
     };
     WalletMethods.prototype.getVersion = function () {
         return this.dataCall(types_1.RPCMethod.GetVersion);
@@ -73,35 +76,95 @@ var WalletMethods = /** @class */ (function () {
     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 () {
         return this.dataCall(types_1.RPCMethod.GetTrackedAssets);
     };
     WalletMethods.prototype.getAssetPrecision = function (params) {
         return this.dataCall(types_1.RPCMethod.GetAssetPrecision, params);
     };
+    WalletMethods.prototype.getAssets = function () {
+        return this.dataCall(types_1.RPCMethod.GetAssets);
+    };
+    WalletMethods.prototype.getAsset = function (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.buildTransaction = function (params) {
         return this.dataCall(types_1.RPCMethod.BuildTransaction, params);
     };
+    WalletMethods.prototype.buildTransactionOffline = function (params) {
+        return this.dataCall(types_1.RPCMethod.BuildTransactionOffline, params);
+    };
+    WalletMethods.prototype.buildUnsignedTransaction = function (params) {
+        return this.dataCall(types_1.RPCMethod.BuildUnsignedTransaction, params);
+    };
+    WalletMethods.prototype.signUnsignedTransaction = function (params) {
+        return this.dataCall(types_1.RPCMethod.SignUnsignedTransaction, params);
+    };
+    WalletMethods.prototype.finalizeUnsignedTransaction = function (params) {
+        return this.dataCall(types_1.RPCMethod.FinalizeUnsignedTransaction, params);
+    };
+    WalletMethods.prototype.clearTxCache = function () {
+        return this.dataCall(types_1.RPCMethod.ClearTxCache);
+    };
     WalletMethods.prototype.listTransactions = function (params) {
         return this.dataCall(types_1.RPCMethod.GetTransaction, params);
     };
     WalletMethods.prototype.isOnline = function () {
         return this.dataCall(types_1.RPCMethod.IsOnline);
     };
+    WalletMethods.prototype.setOnlineMode = function (params) {
+        return this.dataCall(types_1.RPCMethod.SetOfflineMode, params);
+    };
+    WalletMethods.prototype.setOfflineMode = function () {
+        return this.dataCall(types_1.RPCMethod.SetOfflineMode);
+    };
     WalletMethods.prototype.signData = function (data) {
-        return this.dataCall(types_1.RPCMethod.SignData, data);
+        return this.dataCall(types_1.RPCMethod.SignData, data.toObject());
     };
     WalletMethods.prototype.estimateFees = function (params) {
         return this.dataCall(types_1.RPCMethod.EstimateFees, params);
     };
-    WalletMethods.prototype.setOnlineMode = function (params) {
-        return this.dataCall(types_1.RPCMethod.SetOfflineMode, params);
+    WalletMethods.prototype.estimateExtraDataSize = function (params) {
+        return this.dataCall(types_1.RPCMethod.EstimateExtraDataSize, params);
     };
-    WalletMethods.prototype.setOfflineMode = function () {
-        return this.dataCall(types_1.RPCMethod.SetOfflineMode);
+    WalletMethods.prototype.networkInfo = function () {
+        return this.dataCall(types_1.RPCMethod.NetworkInfo);
+    };
+    WalletMethods.prototype.decryptExtraData = function (params) {
+        return this.dataCall(types_1.RPCMethod.DecryptExtraData, params);
+    };
+    WalletMethods.prototype.decryptCiphertext = function (params) {
+        return this.dataCall(types_1.RPCMethod.DecryptCiphertext, params);
+    };
+    WalletMethods.prototype.getMatchingKeys = function (params) {
+        return this.dataCall(types_1.RPCMethod.GetMatchingKeys, params);
+    };
+    WalletMethods.prototype.countMatchingEntries = function (params) {
+        return this.dataCall(types_1.RPCMethod.CountMatchingEntries, params);
+    };
+    WalletMethods.prototype.getValueFromKey = function (params) {
+        return this.dataCall(types_1.RPCMethod.GetValueFromKey, params);
+    };
+    WalletMethods.prototype.store = function (params) {
+        return this.dataCall(types_1.RPCMethod.Store, params);
+    };
+    WalletMethods.prototype["delete"] = function (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) {
+        return this.dataCall(types_1.RPCMethod.HasKey, params);
+    };
+    WalletMethods.prototype.queryDB = function (params) {
+        return this.dataCall(types_1.RPCMethod.QueryDB, params);
     };
     return WalletMethods;
 }());
@@ -114,6 +177,6 @@ var WS = /** @class */ (function (_super) {
         return _this;
     }
     return WS;
-}(websocket_1.WS));
+}(websocket_1.WSRPC));
 exports.WS = WS;
 exports["default"] = WS;

package/dist/cjs/xswd/websocket.js

@@ -16,7 +16,7 @@ var __extends = (this && this.__extends) || (function () {
 })();
 exports.__esModule = true;
 exports.WS = void 0;
-var websocket_1 = require("../lib/websocket");
+var websocket_1 = require("../rpc/websocket");
 var websocket_2 = require("../daemon/websocket");
 var websocket_3 = require("../wallet/websocket");
 var WS = /** @class */ (function (_super) {
@@ -30,9 +30,9 @@ var WS = /** @class */ (function (_super) {
     }
     WS.prototype.authorize = function (app) {
         var data = JSON.stringify(app);
-        return this.call("", {}, data);
+        return this.rawCall(0, data);
     };
     return WS;
-}(websocket_1.WS));
+}(websocket_1.WSRPC));
 exports.WS = WS;
 exports["default"] = WS;

package/dist/esm/address/address.js

@@ -0,0 +1,53 @@
+import { decode, convertBits, encode } from "./bech32.js";
+import { ValueReader } from "../data/value.js";
+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 ValueReader(new Uint8Array(data));
+                this.extraData = reader.read();
+                break;
+            default:
+                throw "invalid address type";
+        }
+    }
+    Address.fromString = function (addr) {
+        var _a = decode(addr), hrp = _a.hrp, decoded = _a.decoded;
+        if (hrp !== PrefixAddress && hrp !== TestnetPrefixAddress) {
+            throw ErrInvalidNetworkPrefix;
+        }
+        var bits = 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 = convertBits(this.publicKey, 8, 5, true);
+        var hrp = PrefixAddress;
+        if (!this.isMainnet) {
+            hrp = TestnetPrefixAddress;
+        }
+        return encode(hrp, bits);
+    };
+    return Address;
+}());
+export default Address;

package/dist/esm/address/bech32.js

@@ -0,0 +1,161 @@
+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 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;
+}
+export 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;
+}
+export 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 };
+}
+export 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));
+}

package/dist/esm/config.js

@@ -16,6 +16,7 @@ export var LOCAL_WALLET_WS = "ws://".concat(LOCAL_WALLET_URL, "/json_rpc");
 export var LOCAL_XSWD_URL = "127.0.0.1:".concat(XSWD_PORT);
 export var LOCAL_XSWD_WS = "ws://".concat(LOCAL_XSWD_URL, "/xswd");
 export var XELIS_ASSET = "0000000000000000000000000000000000000000000000000000000000000000";
+export var XELIS_DECIMALS = 8;
 export default {
     MAINNET_NODE_URL: MAINNET_NODE_URL,
     TESTNET_NODE_URL: TESTNET_NODE_URL,
@@ -33,5 +34,6 @@ export default {
     LOCAL_WALLET_WS: LOCAL_WALLET_WS,
     LOCAL_XSWD_URL: LOCAL_XSWD_URL,
     LOCAL_XSWD_WS: LOCAL_XSWD_WS,
-    XELIS_ASSET: XELIS_ASSET
+    XELIS_ASSET: XELIS_ASSET,
+    XELIS_DECIMALS: XELIS_DECIMALS
 };