@xelis/sdk 0.9.11 → 0.10.1

package/dist/cjs/data/value.js

@@ -0,0 +1,327 @@
+"use strict";
+exports.__esModule = true;
+exports.ValueWriter = exports.ValueReader = exports.Value = exports.ValueType = void 0;
+var element_1 = require("./element");
+var MaxStringSize = 255;
+var ErrMaxStringSize = "string max limit is 255 bytes";
+var MaxBlobSize = 65535;
+var ErrMaxBlobSize = "blob max size is 65535 bytes";
+function ErrUnsupportedValue(value) {
+    return "unsupported value type ".concat(value);
+}
+function getUIntTypeByValue(value) {
+    if (value < 0)
+        throw "invalid uint number";
+    if (value <= 0xFF)
+        return ValueType.U8;
+    if (value <= 0xFFFF)
+        return ValueType.U16;
+    if (value <= 0xFFFFFFFF)
+        return ValueType.U32;
+    if (value <= BigInt("0xFFFFFFFFFFFFFFFF"))
+        return ValueType.U64;
+    if (value <= BigInt("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"))
+        return ValueType.U128;
+    throw "unsupported uint";
+}
+var ValueType;
+(function (ValueType) {
+    ValueType[ValueType["Bool"] = 0] = "Bool";
+    ValueType[ValueType["String"] = 1] = "String";
+    ValueType[ValueType["U8"] = 2] = "U8";
+    ValueType[ValueType["U16"] = 3] = "U16";
+    ValueType[ValueType["U32"] = 4] = "U32";
+    ValueType[ValueType["U64"] = 5] = "U64";
+    ValueType[ValueType["U128"] = 6] = "U128";
+    ValueType[ValueType["Hash"] = 7] = "Hash";
+    ValueType[ValueType["Blob"] = 8] = "Blob";
+})(ValueType = exports.ValueType || (exports.ValueType = {}));
+var Value = /** @class */ (function () {
+    function Value(vType, data) {
+        this.vType = vType;
+        this.data = data;
+    }
+    Value["new"] = function (data) {
+        if (typeof data === "string") {
+            return new Value(ValueType.String, data);
+        }
+        else if (typeof data === "boolean") {
+            return new Value(ValueType.Bool, data);
+        }
+        else if (Array.isArray(data)) {
+            return new Value(ValueType.Blob, data);
+        }
+        else if (data instanceof Uint8Array && data.byteLength === 32) {
+            return new Value(ValueType.Hash, data);
+        }
+        else if (typeof data === "number" || typeof data === "bigint") {
+            var eType = getUIntTypeByValue(data);
+            switch (eType) {
+                case ValueType.U8:
+                    return new Value(ValueType.U8, data);
+                case ValueType.U16:
+                    return new Value(ValueType.U16, data);
+                case ValueType.U32:
+                    return new Value(ValueType.U32, data);
+                case ValueType.U64:
+                    return new Value(ValueType.U64, data);
+                case ValueType.U128:
+                    return new Value(ValueType.U128, data);
+                default:
+                    throw "unsupported data type";
+            }
+        }
+        throw "unsupported data type";
+    };
+    return Value;
+}());
+exports.Value = Value;
+var ValueReader = /** @class */ (function () {
+    function ValueReader(data) {
+        this.data = Array.from(data);
+    }
+    ValueReader.prototype.read = function () {
+        var eType = this.readByte();
+        switch (eType) {
+            case element_1.ElementType.Value:
+                return element_1.Element.value(this.readValue());
+            case element_1.ElementType.Array:
+                var arrSize = this.readByte();
+                var elements = [];
+                for (var i = 0; i < arrSize; i++) {
+                    elements.push(this.read());
+                }
+                return element_1.Element.array(elements);
+            case element_1.ElementType.Fields:
+                var fieldsSize = this.readByte();
+                var map = new Map();
+                for (var i = 0; i < fieldsSize; i++) {
+                    map.set(this.readValue(), this.read());
+                }
+                return element_1.Element.fields(map);
+            default:
+                throw "invalid element type";
+        }
+    };
+    ValueReader.prototype.readByte = function () {
+        return this.data.splice(0, 1)[0];
+    };
+    ValueReader.prototype.readU16 = function () {
+        var arr = new Uint8Array(this.data.splice(0, 2));
+        var view = new DataView(arr.buffer);
+        return view.getUint16(0, false);
+    };
+    ValueReader.prototype.readU32 = function () {
+        var arr = new Uint8Array(this.data.splice(0, 4));
+        var view = new DataView(arr.buffer);
+        return view.getUint32(0, false);
+    };
+    ValueReader.prototype.readU64 = function () {
+        var arr = new Uint8Array(this.data.splice(0, 8));
+        var view = new DataView(arr.buffer);
+        return view.getBigUint64(0, false);
+    };
+    ValueReader.prototype.readU128 = function () {
+        var data = this.data.splice(0, 16);
+        var value = BigInt(0);
+        for (var i = 0; i < 16; i++) {
+            value = (value << BigInt(8)) | BigInt(data[i]);
+        }
+        return value;
+    };
+    ValueReader.prototype.readString = function () {
+        var size = this.readByte();
+        var decoder = new TextDecoder();
+        var data = new Uint8Array(this.data.splice(0, size));
+        return decoder.decode(data);
+    };
+    ValueReader.prototype.readBool = function () {
+        return this.readByte() === 1 ? true : false;
+    };
+    ValueReader.prototype.readHash = function () {
+        return this.data.splice(0, 32);
+    };
+    ValueReader.prototype.readBlob = function () {
+        var size = this.readByte();
+        return this.data.splice(0, size);
+    };
+    ValueReader.prototype.readValue = function () {
+        var vType = this.readByte();
+        switch (vType) {
+            case ValueType.U8:
+                return new Value(vType, this.readByte());
+            case ValueType.U16:
+                return new Value(vType, this.readU16());
+            case ValueType.U32:
+                return new Value(vType, this.readU32());
+            case ValueType.U64:
+                return new Value(vType, this.readU64());
+            case ValueType.U128:
+                return new Value(vType, this.readU128());
+            case ValueType.String:
+                return new Value(vType, this.readString());
+            case ValueType.Bool:
+                return new Value(vType, this.readBool());
+            case ValueType.Blob:
+                return new Value(vType, this.readBlob());
+            case ValueType.Hash:
+                return new Value(vType, this.readHash());
+            default:
+                throw "";
+        }
+    };
+    return ValueReader;
+}());
+exports.ValueReader = ValueReader;
+var ValueWriter = /** @class */ (function () {
+    function ValueWriter() {
+        this.data = [];
+    }
+    ValueWriter.prototype.write = function (dataElement) {
+        var _this = this;
+        var eType = dataElement.validate();
+        switch (eType) {
+            case element_1.ElementType.Value:
+                this.writeU8(element_1.ElementType.Value);
+                this.writeValue(dataElement.value);
+                break;
+            case element_1.ElementType.Array:
+                this.writeU8(element_1.ElementType.Array);
+                var array = dataElement.array;
+                this.writeU8(array.length);
+                array.forEach(function (element) {
+                    _this.write(element);
+                });
+                break;
+            case element_1.ElementType.Fields:
+                this.writeU8(element_1.ElementType.Fields);
+                var fields = dataElement.fields;
+                this.writeU8(fields.size);
+                fields.forEach(function (element, key) {
+                    _this.writeValue(key);
+                    _this.write(element);
+                });
+                break;
+        }
+    };
+    ValueWriter.prototype.appendData = function (data) {
+        var _a;
+        (_a = this.data).push.apply(_a, Array.from(data));
+    };
+    ValueWriter.prototype.appendBuffer = function (buf) {
+        this.appendData(new Uint8Array(buf));
+    };
+    ValueWriter.prototype.writeU8 = function (value) {
+        if (typeof value !== "number") {
+            throw "value is not a number";
+        }
+        this.appendBuffer(new Uint8Array([value]));
+    };
+    ValueWriter.prototype.writeU16 = function (value) {
+        if (typeof value !== "number") {
+            throw "value is not a number";
+        }
+        var buf = new ArrayBuffer(2);
+        var view = new DataView(buf);
+        view.setUint16(0, value, false);
+        this.appendBuffer(buf);
+    };
+    ValueWriter.prototype.writeU32 = function (value) {
+        if (typeof value !== "number") {
+            throw "value is not a number";
+        }
+        var buf = new ArrayBuffer(4);
+        var view = new DataView(buf);
+        view.setUint32(0, value, false);
+        this.appendBuffer(buf);
+    };
+    ValueWriter.prototype.writeU64 = function (value) {
+        if (typeof value !== "bigint") {
+            throw "value is not a bigint";
+        }
+        var buf = new ArrayBuffer(8);
+        var view = new DataView(buf);
+        view.setBigUint64(0, value, false);
+        this.appendBuffer(buf);
+    };
+    ValueWriter.prototype.writeU128 = function (value) {
+        if (typeof value !== "bigint") {
+            throw "value is not a bigint";
+        }
+        var bytes = [];
+        for (var i = 0; i < 16; i++) {
+            var byte = Number((value >> BigInt(8 * (15 - i))) & BigInt(0xFF));
+            bytes.push(byte);
+        }
+        this.appendData(new Uint8Array(bytes));
+    };
+    ValueWriter.prototype.writeString = function (value) {
+        if (typeof value !== "string") {
+            throw "value is not string";
+        }
+        var encoder = new TextEncoder();
+        var data = encoder.encode(value);
+        if (data.length > MaxStringSize) {
+            throw ErrMaxStringSize;
+        }
+        this.writeU8(data.length);
+        this.appendData(data);
+    };
+    ValueWriter.prototype.writeBool = function (value) {
+        if (typeof value !== "boolean") {
+            throw "value is not a boolean";
+        }
+        this.writeU8(value ? 1 : 0);
+    };
+    ValueWriter.prototype.writeBlob = function (value) {
+        this.writeU8(value.length);
+        this.appendData(new Uint8Array(value));
+    };
+    ValueWriter.prototype.writeHash = function (value) {
+        this.appendData(value);
+    };
+    ValueWriter.prototype.writeValue = function (value) {
+        switch (value.vType) {
+            case ValueType.Bool:
+                this.writeU8(ValueType.Bool);
+                this.writeBool(value.data);
+                break;
+            case ValueType.String:
+                this.writeU8(ValueType.String);
+                this.writeString(value.data);
+                break;
+            case ValueType.U8:
+                this.writeU8(ValueType.U8);
+                this.writeU8(value.data);
+                break;
+            case ValueType.U16:
+                this.writeU8(ValueType.U16);
+                this.writeU16(value.data);
+                break;
+            case ValueType.U32:
+                this.writeU8(ValueType.U32);
+                this.writeU32(value.data);
+                break;
+            case ValueType.U64:
+                this.writeU8(ValueType.U64);
+                this.writeU64(value.data);
+                break;
+            case ValueType.U128:
+                this.writeU8(ValueType.U128);
+                this.writeU128(value.data);
+                break;
+            case ValueType.Blob:
+                this.writeU8(ValueType.Blob);
+                this.writeBlob(value.data);
+                break;
+            case ValueType.Hash:
+                this.writeU8(ValueType.Hash);
+                this.writeHash(value.data);
+                break;
+            default:
+                throw ErrUnsupportedValue(value);
+        }
+    };
+    return ValueWriter;
+}());
+exports.ValueWriter = ValueWriter;

package/dist/cjs/{lib/rpc.js → rpc/http.js}

@@ -36,29 +36,34 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 exports.__esModule = true;
-exports.RPC = void 0;
-var parse_data_1 = require("./parse_data");
-var RPC = /** @class */ (function () {
-    function RPC(endpoint) {
+exports.HttpRPC = void 0;
+var parse_json_1 = require("./parse_json/parse_json");
+var HttpRPC = /** @class */ (function () {
+    function HttpRPC(endpoint) {
         this.endpoint = endpoint;
         this.timeout = 3000;
+        this.headers = new Headers();
+        this.headers.set("Content-Type", "application/json");
     }
-    RPC.prototype.post = function (method, params, headers) {
+    HttpRPC.prototype.batchRequest = function (requests) {
         return __awaiter(this, void 0, void 0, function () {
-            var controller_1, body, timeoutId, res, stringData, data, err_1;
+            var controller_1, id_1, body, timeoutId, res, jsonString, items_1, data, err_1;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         _a.trys.push([0, 5, , 6]);
                         controller_1 = new AbortController();
-                        body = JSON.stringify({ id: 1, jsonrpc: '2.0', method: method, params: params });
+                        id_1 = 0;
+                        requests.forEach(function (request) {
+                            request.id = ++id_1;
+                            request.jsonrpc = "2.0";
+                        });
+                        body = JSON.stringify(requests);
                         timeoutId = setTimeout(function () {
                             controller_1.abort();
                         }, this.timeout);
-                        headers = headers || new Headers();
-                        headers.set("Content-Type", "application/json");
                         return [4 /*yield*/, fetch(this.endpoint, {
-                                headers: headers,
+                                headers: this.headers,
                                 method: "POST",
                                 body: body,
                                 signal: controller_1.signal
@@ -69,23 +74,68 @@ var RPC = /** @class */ (function () {
                         if (!res.ok) return [3 /*break*/, 3];
                         return [4 /*yield*/, res.text()];
                     case 2:
-                        stringData = _a.sent();
-                        data = (0, parse_data_1.parseData)(stringData);
+                        jsonString = _a.sent();
+                        items_1 = [];
+                        data = (0, parse_json_1.parseJSON)(jsonString);
+                        data.forEach(function (item) {
+                            if (item.error) {
+                                items_1.push(new Error(item.error.message));
+                            }
+                            else {
+                                items_1.push(item.result);
+                            }
+                        });
+                        return [2 /*return*/, Promise.resolve(items_1)];
+                    case 3: return [2 /*return*/, Promise.reject(new Error("".concat(res.status, " - ").concat(res.statusText)))];
+                    case 4: return [3 /*break*/, 6];
+                    case 5:
+                        err_1 = _a.sent();
+                        return [2 /*return*/, Promise.reject(err_1)];
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    HttpRPC.prototype.request = function (method, params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var controller_2, body, timeoutId, res, jsonString, data, err_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 5, , 6]);
+                        controller_2 = new AbortController();
+                        body = JSON.stringify({ id: 1, jsonrpc: '2.0', method: method, params: params });
+                        timeoutId = setTimeout(function () {
+                            controller_2.abort();
+                        }, this.timeout);
+                        return [4 /*yield*/, fetch(this.endpoint, {
+                                headers: this.headers,
+                                method: "POST",
+                                body: body,
+                                signal: controller_2.signal
+                            })];
+                    case 1:
+                        res = _a.sent();
+                        clearTimeout(timeoutId);
+                        if (!res.ok) return [3 /*break*/, 3];
+                        return [4 /*yield*/, res.text()];
+                    case 2:
+                        jsonString = _a.sent();
+                        data = (0, parse_json_1.parseJSON)(jsonString);
                         if (data.error) {
                             return [2 /*return*/, Promise.reject(new Error(data.error.message))];
                         }
-                        return [2 /*return*/, Promise.resolve(data)];
+                        return [2 /*return*/, Promise.resolve(data.result)];
                     case 3: return [2 /*return*/, Promise.reject(new Error("".concat(res.status, " - ").concat(res.statusText)))];
                     case 4: return [3 /*break*/, 6];
                     case 5:
-                        err_1 = _a.sent();
-                        console.log(err_1);
-                        return [2 /*return*/, Promise.reject(err_1)];
+                        err_2 = _a.sent();
+                        return [2 /*return*/, Promise.reject(err_2)];
                     case 6: return [2 /*return*/];
                 }
             });
         });
     };
-    return RPC;
+    return HttpRPC;
 }());
-exports.RPC = RPC;
+exports.HttpRPC = HttpRPC;

package/dist/cjs/rpc/parse_json/parse_json.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.parseJSON = void 0;
+var json_bigint_1 = __importDefault(require("json-bigint"));
+// do not use JSON.parse() or we loose precision on big numbers
+// for ex: the API returns the nonce as a number instead of a string and JSON.parse() is rounding the number because of overflow
+// instead we will return any BigInt as a string and avoid precision loss
+// NOTE: Previously was using lossless-json with isSafeNumber, but its too slow for big json data
+var parseJSON = function (data) {
+    return (0, json_bigint_1["default"])({ storeAsString: true }).parse(data);
+};
+exports.parseJSON = parseJSON;