@xylabs/sdk-js 2.3.19 → 2.3.20

package/dist/esm2017/index.js

@@ -3,220 +3,374 @@ import BigNumber from 'bn.js';
 export { default as BigNumber } from 'bn.js';
 import Rollbar from 'rollbar';
 
-var ApiStage;
-(function (ApiStage) {
-    ApiStage["Beta"] = "beta";
-    ApiStage["Local"] = "local";
-    ApiStage["Prod"] = "prod";
+var ApiStage;
+(function (ApiStage) {
+    ApiStage["Beta"] = "beta";
+    ApiStage["Local"] = "local";
+    ApiStage["Prod"] = "prod";
 })(ApiStage || (ApiStage = {}));
 
-class ApiClient {
-    constructor(token, stage) {
-        this.stage = stage !== null && stage !== void 0 ? stage : ApiStage.Prod;
-        this.token = token;
-    }
-}
+var ApiClient = /** @class */ (function () {
+    function ApiClient(token, stage) {
+        this.stage = stage !== null && stage !== void 0 ? stage : ApiStage.Prod;
+        this.token = token;
+    }
+    return ApiClient;
+}());
 
-class ApiEndpoint {
-    constructor(config, path) {
-        this.config = config;
-        this.path = path;
-    }
-    get headers() {
-        return this.config.token ? { Authorization: this.config.token } : undefined;
-    }
-    get url() {
-        return `${this.config.apiDomain}/${this.path}`;
-    }
-    get value() {
-        return this._value;
-    }
-    async get() {
-        var _a;
-        return (_a = this._value) !== null && _a !== void 0 ? _a : (await this.fetch());
-    }
-    async fetch() {
-        const response = await axios.get(this.url, { headers: this.headers });
-        if (response.status === 200) {
-            this._value = response.data;
-        }
-        else {
-            throw Error('Unexpected Status Code');
-        }
-        return this._value;
-    }
-    async insert(value) {
-        const response = await axios.post(this.url, value, { headers: this.headers });
-        if (response.status === 200) {
-            this._value = response.data;
-        }
-        else {
-            throw Error('Unexpected Status Code');
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise */
+
+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 (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
         }
-        return this._value;
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 }
 
-/**
- * Error object thrown by assertEx
- */
-class AssertExError extends Error {
-}
-/**
- *
- * Intended for simple null/undefiend checks for variables
- *
- * @param expr - Expression to be evaluated for truthiness
- * @param message - Message in Error if expression is false
- * @throws AssertExError
- * @returns Value of expression
- */
-const assertEx = (expr, message) => {
-    if (expr)
-        return expr;
-    throw new AssertExError(message);
+var ApiEndpoint = /** @class */ (function () {
+    function ApiEndpoint(config, path) {
+        this.config = config;
+        this.path = path;
+    }
+    Object.defineProperty(ApiEndpoint.prototype, "headers", {
+        get: function () {
+            return this.config.token ? { Authorization: this.config.token } : undefined;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ApiEndpoint.prototype, "url", {
+        get: function () {
+            return "".concat(this.config.apiDomain, "/").concat(this.path);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ApiEndpoint.prototype, "value", {
+        get: function () {
+            return this._value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ApiEndpoint.prototype.get = function () {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (!((_a = this._value) !== null && _a !== void 0)) return [3 /*break*/, 1];
+                        _b = _a;
+                        return [3 /*break*/, 3];
+                    case 1: return [4 /*yield*/, this.fetch()];
+                    case 2:
+                        _b = (_c.sent());
+                        _c.label = 3;
+                    case 3: return [2 /*return*/, _b];
+                }
+            });
+        });
+    };
+    ApiEndpoint.prototype.fetch = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, axios.get(this.url, { headers: this.headers })];
+                    case 1:
+                        response = _a.sent();
+                        if (response.status === 200) {
+                            this._value = response.data;
+                        }
+                        else {
+                            throw Error('Unexpected Status Code');
+                        }
+                        return [2 /*return*/, this._value];
+                }
+            });
+        });
+    };
+    ApiEndpoint.prototype.insert = function (value) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, axios.post(this.url, value, { headers: this.headers })];
+                    case 1:
+                        response = _a.sent();
+                        if (response.status === 200) {
+                            this._value = response.data;
+                        }
+                        else {
+                            throw Error('Unexpected Status Code');
+                        }
+                        return [2 /*return*/, this._value];
+                }
+            });
+        });
+    };
+    return ApiEndpoint;
+}());
+
+/**
+ * Error object thrown by assertEx
+ */
+var AssertExError = /** @class */ (function (_super) {
+    __extends(AssertExError, _super);
+    function AssertExError() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return AssertExError;
+}(Error));
+/**
+ *
+ * Intended for simple null/undefiend checks for variables
+ *
+ * @param expr - Expression to be evaluated for truthiness
+ * @param message - Message in Error if expression is false
+ * @throws AssertExError
+ * @returns Value of expression
+ */
+var assertEx = function (expr, message) {
+    if (expr)
+        return expr;
+    throw new AssertExError(message);
 };
 
-const delay = (ms) => {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+var delay = function (ms) {
+    return new Promise(function (resolve) { return setTimeout(resolve, ms); });
 };
 
-const padHex = (hex, byteCount) => {
-    let result = hex;
-    if (hex.length % 2 !== 0) {
-        result = `0${hex}`;
-    }
-    if (byteCount) {
-        while (result.length / 2 < byteCount) {
-            result = `00${result}`;
-        }
-    }
-    return result;
+var padHex = function (hex, byteCount) {
+    var result = hex;
+    if (hex.length % 2 !== 0) {
+        result = "0".concat(hex);
+    }
+    if (byteCount) {
+        while (result.length / 2 < byteCount) {
+            result = "00".concat(result);
+        }
+    }
+    return result;
 };
 
-const isEthAddress = (obj) => (obj === null || obj === void 0 ? void 0 : obj.type) === EthAddress.type;
-class EthAddress {
-    constructor(address) {
-        this.type = EthAddress.type;
-        this.address = address;
-    }
-    equals(address) {
-        if (address) {
-            let inAddress;
-            if (typeof address === 'string') {
-                inAddress = assertEx(EthAddress.fromString(address), 'Bad Address');
-            }
-            else {
-                inAddress = address;
-            }
-            return this.address.eq(inAddress.address);
-        }
-        return false;
-    }
-    static fromString(value, base = 16) {
-        if (value) {
-            const bn = new BigNumber(value.startsWith('0x') ? value.substring(2) : value, base);
-            return new EthAddress(bn);
-        }
-    }
-    static parse(value, base) {
-        if (typeof value === 'string') {
-            return this.fromString(value, base);
-        }
-    }
-    toBigNumber() {
-        return this.address;
-    }
-    toString() {
-        return `0x${this.toHex()}`;
-    }
-    toLowerCaseString() {
-        return this.toString().toLowerCase();
-    }
-    toJSON() {
-        return `0x${this.toHex()}`;
-    }
-    toHex() {
-        return padHex(this.address.toString(16), 20);
-    }
-    toShortString(length = 2) {
-        const hex = this.toHex();
-        const part1 = hex.slice(0, length);
-        const part2 = hex.slice(hex.length - length, hex.length);
-        return `0x${part1}...${part2}`;
-    }
-}
-EthAddress.type = 'EthAddress';
+var isEthAddress = function (obj) { return (obj === null || obj === void 0 ? void 0 : obj.type) === EthAddress.type; };
+var EthAddress = /** @class */ (function () {
+    function EthAddress(address) {
+        this.type = EthAddress.type;
+        this.address = address;
+    }
+    EthAddress.prototype.equals = function (address) {
+        if (address) {
+            var inAddress = void 0;
+            if (typeof address === 'string') {
+                inAddress = assertEx(EthAddress.fromString(address), 'Bad Address');
+            }
+            else {
+                inAddress = address;
+            }
+            return this.address.eq(inAddress.address);
+        }
+        return false;
+    };
+    EthAddress.fromString = function (value, base) {
+        if (base === void 0) { base = 16; }
+        if (value) {
+            var bn = new BigNumber(value.startsWith('0x') ? value.substring(2) : value, base);
+            return new EthAddress(bn);
+        }
+    };
+    EthAddress.parse = function (value, base) {
+        if (typeof value === 'string') {
+            return this.fromString(value, base);
+        }
+    };
+    EthAddress.prototype.toBigNumber = function () {
+        return this.address;
+    };
+    EthAddress.prototype.toString = function () {
+        return "0x".concat(this.toHex());
+    };
+    EthAddress.prototype.toLowerCaseString = function () {
+        return this.toString().toLowerCase();
+    };
+    EthAddress.prototype.toJSON = function () {
+        return "0x".concat(this.toHex());
+    };
+    EthAddress.prototype.toHex = function () {
+        return padHex(this.address.toString(16), 20);
+    };
+    EthAddress.prototype.toShortString = function (length) {
+        if (length === void 0) { length = 2; }
+        var hex = this.toHex();
+        var part1 = hex.slice(0, length);
+        var part2 = hex.slice(hex.length - length, hex.length);
+        return "0x".concat(part1, "...").concat(part2);
+    };
+    EthAddress.type = 'EthAddress';
+    return EthAddress;
+}());
 
-const getApiStage = (hostname) => {
-    if (hostname.startsWith('localhost')) {
-        return ApiStage.Local;
-    }
-    else if (hostname.startsWith('beta.')) {
-        return ApiStage.Beta;
-    }
-    else {
-        return ApiStage.Prod;
-    }
+var getApiStage = function (hostname) {
+    if (hostname.startsWith('localhost')) {
+        return ApiStage.Local;
+    }
+    else if (hostname.startsWith('beta.')) {
+        return ApiStage.Beta;
+    }
+    else {
+        return ApiStage.Prod;
+    }
 };
 
-class Log {
-    constructor(config) {
-        var _a;
-        this.devMode = (_a = config.devMode) !== null && _a !== void 0 ? _a : false;
-        if (config.rollbarToken) {
-            this.rollbar = new Rollbar({
-                accessToken: config.rollbarToken,
-                captureUncaught: true,
-                captureUnhandledRejections: true,
-                codeVersion: config.commitHash,
-                code_version: config.commitHash,
-                payload: Object.assign({ client: {
-                        javascript: {
-                            code_version: config.commitHash,
-                            guess_uncaught_frames: true,
-                            source_map_enabled: true,
-                        },
-                    }, codeVersion: config.commitHash, code_version: config.commitHash, environment: this.devMode ? 'development' : 'production' }, config.payload),
-                sendConfig: true,
-            });
-        }
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    error(...params) {
-        var _a;
-        console.error(params);
-        if (this.devMode) {
-            (_a = this.rollbar) === null || _a === void 0 ? void 0 : _a.error(params);
-        }
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    warn(...params) {
-        var _a;
-        console.warn(params);
-        if (this.devMode) {
-            (_a = this.rollbar) === null || _a === void 0 ? void 0 : _a.warn(params);
-        }
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    info(...params) {
-        if (this.devMode) {
-            console.info(params);
-        }
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    debug(...params) {
-        if (this.devMode) {
-            console.debug(params);
-        }
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    log(...params) {
-        if (this.devMode) {
-            console.log(params);
-        }
-    }
-}
+var Log = /** @class */ (function () {
+    function Log(config) {
+        var _a;
+        this.devMode = (_a = config.devMode) !== null && _a !== void 0 ? _a : false;
+        if (config.rollbarToken) {
+            this.rollbar = new Rollbar({
+                accessToken: config.rollbarToken,
+                captureUncaught: true,
+                captureUnhandledRejections: true,
+                codeVersion: config.commitHash,
+                code_version: config.commitHash,
+                payload: __assign({ client: {
+                        javascript: {
+                            code_version: config.commitHash,
+                            guess_uncaught_frames: true,
+                            source_map_enabled: true,
+                        },
+                    }, codeVersion: config.commitHash, code_version: config.commitHash, environment: this.devMode ? 'development' : 'production' }, config.payload),
+                sendConfig: true,
+            });
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Log.prototype.error = function () {
+        var _a;
+        var params = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            params[_i] = arguments[_i];
+        }
+        console.error(params);
+        if (this.devMode) {
+            (_a = this.rollbar) === null || _a === void 0 ? void 0 : _a.error(params);
+        }
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Log.prototype.warn = function () {
+        var _a;
+        var params = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            params[_i] = arguments[_i];
+        }
+        console.warn(params);
+        if (this.devMode) {
+            (_a = this.rollbar) === null || _a === void 0 ? void 0 : _a.warn(params);
+        }
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Log.prototype.info = function () {
+        var params = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            params[_i] = arguments[_i];
+        }
+        if (this.devMode) {
+            console.info(params);
+        }
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Log.prototype.debug = function () {
+        var params = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            params[_i] = arguments[_i];
+        }
+        if (this.devMode) {
+            console.debug(params);
+        }
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Log.prototype.log = function () {
+        var params = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            params[_i] = arguments[_i];
+        }
+        if (this.devMode) {
+            console.log(params);
+        }
+    };
+    return Log;
+}());
 
 export { ApiClient, ApiEndpoint, ApiStage, EthAddress, Log, assertEx, delay, getApiStage, isEthAddress };
 //# sourceMappingURL=index.js.map