koilib 2.5.0 → 2.5.1

package/dist/koinos.js

@@ -1630,58 +1630,58 @@ exports.utils = {
 /***/ ((module) => {
 
 "use strict";
-
-module.exports = asPromise;
-
-/**
- * Callback as used by {@link util.asPromise}.
- * @typedef asPromiseCallback
- * @type {function}
- * @param {Error|null} error Error, if any
- * @param {...*} params Additional arguments
- * @returns {undefined}
- */
-
-/**
- * Returns a promise from a node-style callback function.
- * @memberof util
- * @param {asPromiseCallback} fn Function to call
- * @param {*} ctx Function context
- * @param {...*} params Function arguments
- * @returns {Promise<*>} Promisified function
- */
-function asPromise(fn, ctx/*, varargs */) {
-    var params  = new Array(arguments.length - 1),
-        offset  = 0,
-        index   = 2,
-        pending = true;
-    while (index < arguments.length)
-        params[offset++] = arguments[index++];
-    return new Promise(function executor(resolve, reject) {
-        params[offset] = function callback(err/*, varargs */) {
-            if (pending) {
-                pending = false;
-                if (err)
-                    reject(err);
-                else {
-                    var params = new Array(arguments.length - 1),
-                        offset = 0;
-                    while (offset < params.length)
-                        params[offset++] = arguments[offset];
-                    resolve.apply(null, params);
-                }
-            }
-        };
-        try {
-            fn.apply(ctx || null, params);
-        } catch (err) {
-            if (pending) {
-                pending = false;
-                reject(err);
-            }
-        }
-    });
-}
+
+module.exports = asPromise;
+
+/**
+ * Callback as used by {@link util.asPromise}.
+ * @typedef asPromiseCallback
+ * @type {function}
+ * @param {Error|null} error Error, if any
+ * @param {...*} params Additional arguments
+ * @returns {undefined}
+ */
+
+/**
+ * Returns a promise from a node-style callback function.
+ * @memberof util
+ * @param {asPromiseCallback} fn Function to call
+ * @param {*} ctx Function context
+ * @param {...*} params Function arguments
+ * @returns {Promise<*>} Promisified function
+ */
+function asPromise(fn, ctx/*, varargs */) {
+    var params  = new Array(arguments.length - 1),
+        offset  = 0,
+        index   = 2,
+        pending = true;
+    while (index < arguments.length)
+        params[offset++] = arguments[index++];
+    return new Promise(function executor(resolve, reject) {
+        params[offset] = function callback(err/*, varargs */) {
+            if (pending) {
+                pending = false;
+                if (err)
+                    reject(err);
+                else {
+                    var params = new Array(arguments.length - 1),
+                        offset = 0;
+                    while (offset < params.length)
+                        params[offset++] = arguments[offset];
+                    resolve.apply(null, params);
+                }
+            }
+        };
+        try {
+            fn.apply(ctx || null, params);
+        } catch (err) {
+            if (pending) {
+                pending = false;
+                reject(err);
+            }
+        }
+    });
+}
 
 
 /***/ }),
@@ -1690,145 +1690,145 @@ function asPromise(fn, ctx/*, varargs */) {
 /***/ ((__unused_webpack_module, exports) => {
 
 "use strict";
-
-
-/**
- * A minimal base64 implementation for number arrays.
- * @memberof util
- * @namespace
- */
-var base64 = exports;
-
-/**
- * Calculates the byte length of a base64 encoded string.
- * @param {string} string Base64 encoded string
- * @returns {number} Byte length
- */
-base64.length = function length(string) {
-    var p = string.length;
-    if (!p)
-        return 0;
-    var n = 0;
-    while (--p % 4 > 1 && string.charAt(p) === "=")
-        ++n;
-    return Math.ceil(string.length * 3) / 4 - n;
-};
-
-// Base64 encoding table
-var b64 = new Array(64);
-
-// Base64 decoding table
-var s64 = new Array(123);
-
-// 65..90, 97..122, 48..57, 43, 47
-for (var i = 0; i < 64;)
-    s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 | 43] = i++;
-
-/**
- * Encodes a buffer to a base64 encoded string.
- * @param {Uint8Array} buffer Source buffer
- * @param {number} start Source start
- * @param {number} end Source end
- * @returns {string} Base64 encoded string
- */
-base64.encode = function encode(buffer, start, end) {
-    var parts = null,
-        chunk = [];
-    var i = 0, // output index
-        j = 0, // goto index
-        t;     // temporary
-    while (start < end) {
-        var b = buffer[start++];
-        switch (j) {
-            case 0:
-                chunk[i++] = b64[b >> 2];
-                t = (b & 3) << 4;
-                j = 1;
-                break;
-            case 1:
-                chunk[i++] = b64[t | b >> 4];
-                t = (b & 15) << 2;
-                j = 2;
-                break;
-            case 2:
-                chunk[i++] = b64[t | b >> 6];
-                chunk[i++] = b64[b & 63];
-                j = 0;
-                break;
-        }
-        if (i > 8191) {
-            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
-            i = 0;
-        }
-    }
-    if (j) {
-        chunk[i++] = b64[t];
-        chunk[i++] = 61;
-        if (j === 1)
-            chunk[i++] = 61;
-    }
-    if (parts) {
-        if (i)
-            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
-        return parts.join("");
-    }
-    return String.fromCharCode.apply(String, chunk.slice(0, i));
-};
-
-var invalidEncoding = "invalid encoding";
-
-/**
- * Decodes a base64 encoded string to a buffer.
- * @param {string} string Source string
- * @param {Uint8Array} buffer Destination buffer
- * @param {number} offset Destination offset
- * @returns {number} Number of bytes written
- * @throws {Error} If encoding is invalid
- */
-base64.decode = function decode(string, buffer, offset) {
-    var start = offset;
-    var j = 0, // goto index
-        t;     // temporary
-    for (var i = 0; i < string.length;) {
-        var c = string.charCodeAt(i++);
-        if (c === 61 && j > 1)
-            break;
-        if ((c = s64[c]) === undefined)
-            throw Error(invalidEncoding);
-        switch (j) {
-            case 0:
-                t = c;
-                j = 1;
-                break;
-            case 1:
-                buffer[offset++] = t << 2 | (c & 48) >> 4;
-                t = c;
-                j = 2;
-                break;
-            case 2:
-                buffer[offset++] = (t & 15) << 4 | (c & 60) >> 2;
-                t = c;
-                j = 3;
-                break;
-            case 3:
-                buffer[offset++] = (t & 3) << 6 | c;
-                j = 0;
-                break;
-        }
-    }
-    if (j === 1)
-        throw Error(invalidEncoding);
-    return offset - start;
-};
-
-/**
- * Tests if the specified string appears to be base64 encoded.
- * @param {string} string String to test
- * @returns {boolean} `true` if probably base64 encoded, otherwise false
- */
-base64.test = function test(string) {
-    return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(string);
-};
+
+
+/**
+ * A minimal base64 implementation for number arrays.
+ * @memberof util
+ * @namespace
+ */
+var base64 = exports;
+
+/**
+ * Calculates the byte length of a base64 encoded string.
+ * @param {string} string Base64 encoded string
+ * @returns {number} Byte length
+ */
+base64.length = function length(string) {
+    var p = string.length;
+    if (!p)
+        return 0;
+    var n = 0;
+    while (--p % 4 > 1 && string.charAt(p) === "=")
+        ++n;
+    return Math.ceil(string.length * 3) / 4 - n;
+};
+
+// Base64 encoding table
+var b64 = new Array(64);
+
+// Base64 decoding table
+var s64 = new Array(123);
+
+// 65..90, 97..122, 48..57, 43, 47
+for (var i = 0; i < 64;)
+    s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 | 43] = i++;
+
+/**
+ * Encodes a buffer to a base64 encoded string.
+ * @param {Uint8Array} buffer Source buffer
+ * @param {number} start Source start
+ * @param {number} end Source end
+ * @returns {string} Base64 encoded string
+ */
+base64.encode = function encode(buffer, start, end) {
+    var parts = null,
+        chunk = [];
+    var i = 0, // output index
+        j = 0, // goto index
+        t;     // temporary
+    while (start < end) {
+        var b = buffer[start++];
+        switch (j) {
+            case 0:
+                chunk[i++] = b64[b >> 2];
+                t = (b & 3) << 4;
+                j = 1;
+                break;
+            case 1:
+                chunk[i++] = b64[t | b >> 4];
+                t = (b & 15) << 2;
+                j = 2;
+                break;
+            case 2:
+                chunk[i++] = b64[t | b >> 6];
+                chunk[i++] = b64[b & 63];
+                j = 0;
+                break;
+        }
+        if (i > 8191) {
+            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
+            i = 0;
+        }
+    }
+    if (j) {
+        chunk[i++] = b64[t];
+        chunk[i++] = 61;
+        if (j === 1)
+            chunk[i++] = 61;
+    }
+    if (parts) {
+        if (i)
+            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
+        return parts.join("");
+    }
+    return String.fromCharCode.apply(String, chunk.slice(0, i));
+};
+
+var invalidEncoding = "invalid encoding";
+
+/**
+ * Decodes a base64 encoded string to a buffer.
+ * @param {string} string Source string
+ * @param {Uint8Array} buffer Destination buffer
+ * @param {number} offset Destination offset
+ * @returns {number} Number of bytes written
+ * @throws {Error} If encoding is invalid
+ */
+base64.decode = function decode(string, buffer, offset) {
+    var start = offset;
+    var j = 0, // goto index
+        t;     // temporary
+    for (var i = 0; i < string.length;) {
+        var c = string.charCodeAt(i++);
+        if (c === 61 && j > 1)
+            break;
+        if ((c = s64[c]) === undefined)
+            throw Error(invalidEncoding);
+        switch (j) {
+            case 0:
+                t = c;
+                j = 1;
+                break;
+            case 1:
+                buffer[offset++] = t << 2 | (c & 48) >> 4;
+                t = c;
+                j = 2;
+                break;
+            case 2:
+                buffer[offset++] = (t & 15) << 4 | (c & 60) >> 2;
+                t = c;
+                j = 3;
+                break;
+            case 3:
+                buffer[offset++] = (t & 3) << 6 | c;
+                j = 0;
+                break;
+        }
+    }
+    if (j === 1)
+        throw Error(invalidEncoding);
+    return offset - start;
+};
+
+/**
+ * Tests if the specified string appears to be base64 encoded.
+ * @param {string} string String to test
+ * @returns {boolean} `true` if probably base64 encoded, otherwise false
+ */
+base64.test = function test(string) {
+    return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(string);
+};
 
 
 /***/ }),
@@ -1837,105 +1837,105 @@ base64.test = function test(string) {
 /***/ ((module) => {
 
 "use strict";
-
-module.exports = codegen;
-
-/**
- * Begins generating a function.
- * @memberof util
- * @param {string[]} functionParams Function parameter names
- * @param {string} [functionName] Function name if not anonymous
- * @returns {Codegen} Appender that appends code to the function's body
- */
-function codegen(functionParams, functionName) {
-
-    /* istanbul ignore if */
-    if (typeof functionParams === "string") {
-        functionName = functionParams;
-        functionParams = undefined;
-    }
-
-    var body = [];
-
-    /**
-     * Appends code to the function's body or finishes generation.
-     * @typedef Codegen
-     * @type {function}
-     * @param {string|Object.<string,*>} [formatStringOrScope] Format string or, to finish the function, an object of additional scope variables, if any
-     * @param {...*} [formatParams] Format parameters
-     * @returns {Codegen|Function} Itself or the generated function if finished
-     * @throws {Error} If format parameter counts do not match
-     */
-
-    function Codegen(formatStringOrScope) {
-        // note that explicit array handling below makes this ~50% faster
-
-        // finish the function
-        if (typeof formatStringOrScope !== "string") {
-            var source = toString();
-            if (codegen.verbose)
-                console.log("codegen: " + source); // eslint-disable-line no-console
-            source = "return " + source;
-            if (formatStringOrScope) {
-                var scopeKeys   = Object.keys(formatStringOrScope),
-                    scopeParams = new Array(scopeKeys.length + 1),
-                    scopeValues = new Array(scopeKeys.length),
-                    scopeOffset = 0;
-                while (scopeOffset < scopeKeys.length) {
-                    scopeParams[scopeOffset] = scopeKeys[scopeOffset];
-                    scopeValues[scopeOffset] = formatStringOrScope[scopeKeys[scopeOffset++]];
-                }
-                scopeParams[scopeOffset] = source;
-                return Function.apply(null, scopeParams).apply(null, scopeValues); // eslint-disable-line no-new-func
-            }
-            return Function(source)(); // eslint-disable-line no-new-func
-        }
-
-        // otherwise append to body
-        var formatParams = new Array(arguments.length - 1),
-            formatOffset = 0;
-        while (formatOffset < formatParams.length)
-            formatParams[formatOffset] = arguments[++formatOffset];
-        formatOffset = 0;
-        formatStringOrScope = formatStringOrScope.replace(/%([%dfijs])/g, function replace($0, $1) {
-            var value = formatParams[formatOffset++];
-            switch ($1) {
-                case "d": case "f": return String(Number(value));
-                case "i": return String(Math.floor(value));
-                case "j": return JSON.stringify(value);
-                case "s": return String(value);
-            }
-            return "%";
-        });
-        if (formatOffset !== formatParams.length)
-            throw Error("parameter count mismatch");
-        body.push(formatStringOrScope);
-        return Codegen;
-    }
-
-    function toString(functionNameOverride) {
-        return "function " + (functionNameOverride || functionName || "") + "(" + (functionParams && functionParams.join(",") || "") + "){\n  " + body.join("\n  ") + "\n}";
-    }
-
-    Codegen.toString = toString;
-    return Codegen;
-}
-
-/**
- * Begins generating a function.
- * @memberof util
- * @function codegen
- * @param {string} [functionName] Function name if not anonymous
- * @returns {Codegen} Appender that appends code to the function's body
- * @variation 2
- */
-
-/**
- * When set to `true`, codegen will log generated code to console. Useful for debugging.
- * @name util.codegen.verbose
- * @type {boolean}
- */
-codegen.verbose = false;
+
+module.exports = codegen;
+
+/**
+ * Begins generating a function.
+ * @memberof util
+ * @param {string[]} functionParams Function parameter names
+ * @param {string} [functionName] Function name if not anonymous
+ * @returns {Codegen} Appender that appends code to the function's body
+ */
+function codegen(functionParams, functionName) {
+
+    /* istanbul ignore if */
+    if (typeof functionParams === "string") {
+        functionName = functionParams;
+        functionParams = undefined;
+    }
+
+    var body = [];
+
+    /**
+     * Appends code to the function's body or finishes generation.
+     * @typedef Codegen
+     * @type {function}
+     * @param {string|Object.<string,*>} [formatStringOrScope] Format string or, to finish the function, an object of additional scope variables, if any
+     * @param {...*} [formatParams] Format parameters
+     * @returns {Codegen|Function} Itself or the generated function if finished
+     * @throws {Error} If format parameter counts do not match
+     */
+
+    function Codegen(formatStringOrScope) {
+        // note that explicit array handling below makes this ~50% faster
+
+        // finish the function
+        if (typeof formatStringOrScope !== "string") {
+            var source = toString();
+            if (codegen.verbose)
+                console.log("codegen: " + source); // eslint-disable-line no-console
+            source = "return " + source;
+            if (formatStringOrScope) {
+                var scopeKeys   = Object.keys(formatStringOrScope),
+                    scopeParams = new Array(scopeKeys.length + 1),
+                    scopeValues = new Array(scopeKeys.length),
+                    scopeOffset = 0;
+                while (scopeOffset < scopeKeys.length) {
+                    scopeParams[scopeOffset] = scopeKeys[scopeOffset];
+                    scopeValues[scopeOffset] = formatStringOrScope[scopeKeys[scopeOffset++]];
+                }
+                scopeParams[scopeOffset] = source;
+                return Function.apply(null, scopeParams).apply(null, scopeValues); // eslint-disable-line no-new-func
+            }
+            return Function(source)(); // eslint-disable-line no-new-func
+        }
+
+        // otherwise append to body
+        var formatParams = new Array(arguments.length - 1),
+            formatOffset = 0;
+        while (formatOffset < formatParams.length)
+            formatParams[formatOffset] = arguments[++formatOffset];
+        formatOffset = 0;
+        formatStringOrScope = formatStringOrScope.replace(/%([%dfijs])/g, function replace($0, $1) {
+            var value = formatParams[formatOffset++];
+            switch ($1) {
+                case "d": case "f": return String(Number(value));
+                case "i": return String(Math.floor(value));
+                case "j": return JSON.stringify(value);
+                case "s": return String(value);
+            }
+            return "%";
+        });
+        if (formatOffset !== formatParams.length)
+            throw Error("parameter count mismatch");
+        body.push(formatStringOrScope);
+        return Codegen;
+    }
+
+    function toString(functionNameOverride) {
+        return "function " + (functionNameOverride || functionName || "") + "(" + (functionParams && functionParams.join(",") || "") + "){\n  " + body.join("\n  ") + "\n}";
+    }
+
+    Codegen.toString = toString;
+    return Codegen;
+}
+
+/**
+ * Begins generating a function.
+ * @memberof util
+ * @function codegen
+ * @param {string} [functionName] Function name if not anonymous
+ * @returns {Codegen} Appender that appends code to the function's body
+ * @variation 2
+ */
+
+/**
+ * When set to `true`, codegen will log generated code to console. Useful for debugging.
+ * @name util.codegen.verbose
+ * @type {boolean}
+ */
+codegen.verbose = false;
 
 
 /***/ }),
@@ -1944,82 +1944,82 @@ codegen.verbose = false;
 /***/ ((module) => {
 
 "use strict";
-
-module.exports = EventEmitter;
-
-/**
- * Constructs a new event emitter instance.
- * @classdesc A minimal event emitter.
- * @memberof util
- * @constructor
- */
-function EventEmitter() {
-
-    /**
-     * Registered listeners.
-     * @type {Object.<string,*>}
-     * @private
-     */
-    this._listeners = {};
-}
-
-/**
- * Registers an event listener.
- * @param {string} evt Event name
- * @param {function} fn Listener
- * @param {*} [ctx] Listener context
- * @returns {util.EventEmitter} `this`
- */
-EventEmitter.prototype.on = function on(evt, fn, ctx) {
-    (this._listeners[evt] || (this._listeners[evt] = [])).push({
-        fn  : fn,
-        ctx : ctx || this
-    });
-    return this;
-};
-
-/**
- * Removes an event listener or any matching listeners if arguments are omitted.
- * @param {string} [evt] Event name. Removes all listeners if omitted.
- * @param {function} [fn] Listener to remove. Removes all listeners of `evt` if omitted.
- * @returns {util.EventEmitter} `this`
- */
-EventEmitter.prototype.off = function off(evt, fn) {
-    if (evt === undefined)
-        this._listeners = {};
-    else {
-        if (fn === undefined)
-            this._listeners[evt] = [];
-        else {
-            var listeners = this._listeners[evt];
-            for (var i = 0; i < listeners.length;)
-                if (listeners[i].fn === fn)
-                    listeners.splice(i, 1);
-                else
-                    ++i;
-        }
-    }
-    return this;
-};
-
-/**
- * Emits an event by calling its listeners with the specified arguments.
- * @param {string} evt Event name
- * @param {...*} args Arguments
- * @returns {util.EventEmitter} `this`
- */
-EventEmitter.prototype.emit = function emit(evt) {
-    var listeners = this._listeners[evt];
-    if (listeners) {
-        var args = [],
-            i = 1;
-        for (; i < arguments.length;)
-            args.push(arguments[i++]);
-        for (i = 0; i < listeners.length;)
-            listeners[i].fn.apply(listeners[i++].ctx, args);
-    }
-    return this;
-};
+
+module.exports = EventEmitter;
+
+/**
+ * Constructs a new event emitter instance.
+ * @classdesc A minimal event emitter.
+ * @memberof util
+ * @constructor
+ */
+function EventEmitter() {
+
+    /**
+     * Registered listeners.
+     * @type {Object.<string,*>}
+     * @private
+     */
+    this._listeners = {};
+}
+
+/**
+ * Registers an event listener.
+ * @param {string} evt Event name
+ * @param {function} fn Listener
+ * @param {*} [ctx] Listener context
+ * @returns {util.EventEmitter} `this`
+ */
+EventEmitter.prototype.on = function on(evt, fn, ctx) {
+    (this._listeners[evt] || (this._listeners[evt] = [])).push({
+        fn  : fn,
+        ctx : ctx || this
+    });
+    return this;
+};
+
+/**
+ * Removes an event listener or any matching listeners if arguments are omitted.
+ * @param {string} [evt] Event name. Removes all listeners if omitted.
+ * @param {function} [fn] Listener to remove. Removes all listeners of `evt` if omitted.
+ * @returns {util.EventEmitter} `this`
+ */
+EventEmitter.prototype.off = function off(evt, fn) {
+    if (evt === undefined)
+        this._listeners = {};
+    else {
+        if (fn === undefined)
+            this._listeners[evt] = [];
+        else {
+            var listeners = this._listeners[evt];
+            for (var i = 0; i < listeners.length;)
+                if (listeners[i].fn === fn)
+                    listeners.splice(i, 1);
+                else
+                    ++i;
+        }
+    }
+    return this;
+};
+
+/**
+ * Emits an event by calling its listeners with the specified arguments.
+ * @param {string} evt Event name
+ * @param {...*} args Arguments
+ * @returns {util.EventEmitter} `this`
+ */
+EventEmitter.prototype.emit = function emit(evt) {
+    var listeners = this._listeners[evt];
+    if (listeners) {
+        var args = [],
+            i = 1;
+        for (; i < arguments.length;)
+            args.push(arguments[i++]);
+        for (i = 0; i < listeners.length;)
+            listeners[i].fn.apply(listeners[i++].ctx, args);
+    }
+    return this;
+};
 
 
 /***/ }),
@@ -2028,780 +2028,780 @@ EventEmitter.prototype.emit = function emit(evt) {
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 "use strict";
+
+module.exports = fetch;
+
+var asPromise = __webpack_require__(4537),
+    inquire   = __webpack_require__(7199);
+
+var fs = inquire("fs");
+
+/**
+ * Node-style callback as used by {@link util.fetch}.
+ * @typedef FetchCallback
+ * @type {function}
+ * @param {?Error} error Error, if any, otherwise `null`
+ * @param {string} [contents] File contents, if there hasn't been an error
+ * @returns {undefined}
+ */
+
+/**
+ * Options as used by {@link util.fetch}.
+ * @typedef FetchOptions
+ * @type {Object}
+ * @property {boolean} [binary=false] Whether expecting a binary response
+ * @property {boolean} [xhr=false] If `true`, forces the use of XMLHttpRequest
+ */
+
+/**
+ * Fetches the contents of a file.
+ * @memberof util
+ * @param {string} filename File path or url
+ * @param {FetchOptions} options Fetch options
+ * @param {FetchCallback} callback Callback function
+ * @returns {undefined}
+ */
+function fetch(filename, options, callback) {
+    if (typeof options === "function") {
+        callback = options;
+        options = {};
+    } else if (!options)
+        options = {};
+
+    if (!callback)
+        return asPromise(fetch, this, filename, options); // eslint-disable-line no-invalid-this
+
+    // if a node-like filesystem is present, try it first but fall back to XHR if nothing is found.
+    if (!options.xhr && fs && fs.readFile)
+        return fs.readFile(filename, function fetchReadFileCallback(err, contents) {
+            return err && typeof XMLHttpRequest !== "undefined"
+                ? fetch.xhr(filename, options, callback)
+                : err
+                ? callback(err)
+                : callback(null, options.binary ? contents : contents.toString("utf8"));
+        });
+
+    // use the XHR version otherwise.
+    return fetch.xhr(filename, options, callback);
+}
+
+/**
+ * Fetches the contents of a file.
+ * @name util.fetch
+ * @function
+ * @param {string} path File path or url
+ * @param {FetchCallback} callback Callback function
+ * @returns {undefined}
+ * @variation 2
+ */
+
+/**
+ * Fetches the contents of a file.
+ * @name util.fetch
+ * @function
+ * @param {string} path File path or url
+ * @param {FetchOptions} [options] Fetch options
+ * @returns {Promise<string|Uint8Array>} Promise
+ * @variation 3
+ */
+
+/**/
+fetch.xhr = function fetch_xhr(filename, options, callback) {
+    var xhr = new XMLHttpRequest();
+    xhr.onreadystatechange /* works everywhere */ = function fetchOnReadyStateChange() {
+
+        if (xhr.readyState !== 4)
+            return undefined;
+
+        // local cors security errors return status 0 / empty string, too. afaik this cannot be
+        // reliably distinguished from an actually empty file for security reasons. feel free
+        // to send a pull request if you are aware of a solution.
+        if (xhr.status !== 0 && xhr.status !== 200)
+            return callback(Error("status " + xhr.status));
+
+        // if binary data is expected, make sure that some sort of array is returned, even if
+        // ArrayBuffers are not supported. the binary string fallback, however, is unsafe.
+        if (options.binary) {
+            var buffer = xhr.response;
+            if (!buffer) {
+                buffer = [];
+                for (var i = 0; i < xhr.responseText.length; ++i)
+                    buffer.push(xhr.responseText.charCodeAt(i) & 255);
+            }
+            return callback(null, typeof Uint8Array !== "undefined" ? new Uint8Array(buffer) : buffer);
+        }
+        return callback(null, xhr.responseText);
+    };
+
+    if (options.binary) {
+        // ref: https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/Sending_and_Receiving_Binary_Data#Receiving_binary_data_in_older_browsers
+        if ("overrideMimeType" in xhr)
+            xhr.overrideMimeType("text/plain; charset=x-user-defined");
+        xhr.responseType = "arraybuffer";
+    }
+
+    xhr.open("GET", filename);
+    xhr.send();
+};
 
-module.exports = fetch;
 
-var asPromise = __webpack_require__(4537),
-    inquire   = __webpack_require__(7199);
-
-var fs = inquire("fs");
+/***/ }),
 
-/**
- * Node-style callback as used by {@link util.fetch}.
- * @typedef FetchCallback
- * @type {function}
- * @param {?Error} error Error, if any, otherwise `null`
- * @param {string} [contents] File contents, if there hasn't been an error
- * @returns {undefined}
- */
+/***/ 945:
+/***/ ((module) => {
 
-/**
- * Options as used by {@link util.fetch}.
- * @typedef FetchOptions
- * @type {Object}
- * @property {boolean} [binary=false] Whether expecting a binary response
- * @property {boolean} [xhr=false] If `true`, forces the use of XMLHttpRequest
- */
+"use strict";
+
+
+module.exports = factory(factory);
+
+/**
+ * Reads / writes floats / doubles from / to buffers.
+ * @name util.float
+ * @namespace
+ */
+
+/**
+ * Writes a 32 bit float to a buffer using little endian byte order.
+ * @name util.float.writeFloatLE
+ * @function
+ * @param {number} val Value to write
+ * @param {Uint8Array} buf Target buffer
+ * @param {number} pos Target buffer offset
+ * @returns {undefined}
+ */
+
+/**
+ * Writes a 32 bit float to a buffer using big endian byte order.
+ * @name util.float.writeFloatBE
+ * @function
+ * @param {number} val Value to write
+ * @param {Uint8Array} buf Target buffer
+ * @param {number} pos Target buffer offset
+ * @returns {undefined}
+ */
+
+/**
+ * Reads a 32 bit float from a buffer using little endian byte order.
+ * @name util.float.readFloatLE
+ * @function
+ * @param {Uint8Array} buf Source buffer
+ * @param {number} pos Source buffer offset
+ * @returns {number} Value read
+ */
+
+/**
+ * Reads a 32 bit float from a buffer using big endian byte order.
+ * @name util.float.readFloatBE
+ * @function
+ * @param {Uint8Array} buf Source buffer
+ * @param {number} pos Source buffer offset
+ * @returns {number} Value read
+ */
+
+/**
+ * Writes a 64 bit double to a buffer using little endian byte order.
+ * @name util.float.writeDoubleLE
+ * @function
+ * @param {number} val Value to write
+ * @param {Uint8Array} buf Target buffer
+ * @param {number} pos Target buffer offset
+ * @returns {undefined}
+ */
+
+/**
+ * Writes a 64 bit double to a buffer using big endian byte order.
+ * @name util.float.writeDoubleBE
+ * @function
+ * @param {number} val Value to write
+ * @param {Uint8Array} buf Target buffer
+ * @param {number} pos Target buffer offset
+ * @returns {undefined}
+ */
+
+/**
+ * Reads a 64 bit double from a buffer using little endian byte order.
+ * @name util.float.readDoubleLE
+ * @function
+ * @param {Uint8Array} buf Source buffer
+ * @param {number} pos Source buffer offset
+ * @returns {number} Value read
+ */
+
+/**
+ * Reads a 64 bit double from a buffer using big endian byte order.
+ * @name util.float.readDoubleBE
+ * @function
+ * @param {Uint8Array} buf Source buffer
+ * @param {number} pos Source buffer offset
+ * @returns {number} Value read
+ */
+
+// Factory function for the purpose of node-based testing in modified global environments
+function factory(exports) {
+
+    // float: typed array
+    if (typeof Float32Array !== "undefined") (function() {
+
+        var f32 = new Float32Array([ -0 ]),
+            f8b = new Uint8Array(f32.buffer),
+            le  = f8b[3] === 128;
+
+        function writeFloat_f32_cpy(val, buf, pos) {
+            f32[0] = val;
+            buf[pos    ] = f8b[0];
+            buf[pos + 1] = f8b[1];
+            buf[pos + 2] = f8b[2];
+            buf[pos + 3] = f8b[3];
+        }
+
+        function writeFloat_f32_rev(val, buf, pos) {
+            f32[0] = val;
+            buf[pos    ] = f8b[3];
+            buf[pos + 1] = f8b[2];
+            buf[pos + 2] = f8b[1];
+            buf[pos + 3] = f8b[0];
+        }
+
+        /* istanbul ignore next */
+        exports.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;
+        /* istanbul ignore next */
+        exports.writeFloatBE = le ? writeFloat_f32_rev : writeFloat_f32_cpy;
+
+        function readFloat_f32_cpy(buf, pos) {
+            f8b[0] = buf[pos    ];
+            f8b[1] = buf[pos + 1];
+            f8b[2] = buf[pos + 2];
+            f8b[3] = buf[pos + 3];
+            return f32[0];
+        }
+
+        function readFloat_f32_rev(buf, pos) {
+            f8b[3] = buf[pos    ];
+            f8b[2] = buf[pos + 1];
+            f8b[1] = buf[pos + 2];
+            f8b[0] = buf[pos + 3];
+            return f32[0];
+        }
+
+        /* istanbul ignore next */
+        exports.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;
+        /* istanbul ignore next */
+        exports.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;
+
+    // float: ieee754
+    })(); else (function() {
+
+        function writeFloat_ieee754(writeUint, val, buf, pos) {
+            var sign = val < 0 ? 1 : 0;
+            if (sign)
+                val = -val;
+            if (val === 0)
+                writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos);
+            else if (isNaN(val))
+                writeUint(2143289344, buf, pos);
+            else if (val > 3.4028234663852886e+38) // +-Infinity
+                writeUint((sign << 31 | 2139095040) >>> 0, buf, pos);
+            else if (val < 1.1754943508222875e-38) // denormal
+                writeUint((sign << 31 | Math.round(val / 1.401298464324817e-45)) >>> 0, buf, pos);
+            else {
+                var exponent = Math.floor(Math.log(val) / Math.LN2),
+                    mantissa = Math.round(val * Math.pow(2, -exponent) * 8388608) & 8388607;
+                writeUint((sign << 31 | exponent + 127 << 23 | mantissa) >>> 0, buf, pos);
+            }
+        }
+
+        exports.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);
+        exports.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);
+
+        function readFloat_ieee754(readUint, buf, pos) {
+            var uint = readUint(buf, pos),
+                sign = (uint >> 31) * 2 + 1,
+                exponent = uint >>> 23 & 255,
+                mantissa = uint & 8388607;
+            return exponent === 255
+                ? mantissa
+                ? NaN
+                : sign * Infinity
+                : exponent === 0 // denormal
+                ? sign * 1.401298464324817e-45 * mantissa
+                : sign * Math.pow(2, exponent - 150) * (mantissa + 8388608);
+        }
+
+        exports.readFloatLE = readFloat_ieee754.bind(null, readUintLE);
+        exports.readFloatBE = readFloat_ieee754.bind(null, readUintBE);
+
+    })();
+
+    // double: typed array
+    if (typeof Float64Array !== "undefined") (function() {
+
+        var f64 = new Float64Array([-0]),
+            f8b = new Uint8Array(f64.buffer),
+            le  = f8b[7] === 128;
+
+        function writeDouble_f64_cpy(val, buf, pos) {
+            f64[0] = val;
+            buf[pos    ] = f8b[0];
+            buf[pos + 1] = f8b[1];
+            buf[pos + 2] = f8b[2];
+            buf[pos + 3] = f8b[3];
+            buf[pos + 4] = f8b[4];
+            buf[pos + 5] = f8b[5];
+            buf[pos + 6] = f8b[6];
+            buf[pos + 7] = f8b[7];
+        }
+
+        function writeDouble_f64_rev(val, buf, pos) {
+            f64[0] = val;
+            buf[pos    ] = f8b[7];
+            buf[pos + 1] = f8b[6];
+            buf[pos + 2] = f8b[5];
+            buf[pos + 3] = f8b[4];
+            buf[pos + 4] = f8b[3];
+            buf[pos + 5] = f8b[2];
+            buf[pos + 6] = f8b[1];
+            buf[pos + 7] = f8b[0];
+        }
+
+        /* istanbul ignore next */
+        exports.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;
+        /* istanbul ignore next */
+        exports.writeDoubleBE = le ? writeDouble_f64_rev : writeDouble_f64_cpy;
+
+        function readDouble_f64_cpy(buf, pos) {
+            f8b[0] = buf[pos    ];
+            f8b[1] = buf[pos + 1];
+            f8b[2] = buf[pos + 2];
+            f8b[3] = buf[pos + 3];
+            f8b[4] = buf[pos + 4];
+            f8b[5] = buf[pos + 5];
+            f8b[6] = buf[pos + 6];
+            f8b[7] = buf[pos + 7];
+            return f64[0];
+        }
+
+        function readDouble_f64_rev(buf, pos) {
+            f8b[7] = buf[pos    ];
+            f8b[6] = buf[pos + 1];
+            f8b[5] = buf[pos + 2];
+            f8b[4] = buf[pos + 3];
+            f8b[3] = buf[pos + 4];
+            f8b[2] = buf[pos + 5];
+            f8b[1] = buf[pos + 6];
+            f8b[0] = buf[pos + 7];
+            return f64[0];
+        }
+
+        /* istanbul ignore next */
+        exports.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;
+        /* istanbul ignore next */
+        exports.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;
+
+    // double: ieee754
+    })(); else (function() {
+
+        function writeDouble_ieee754(writeUint, off0, off1, val, buf, pos) {
+            var sign = val < 0 ? 1 : 0;
+            if (sign)
+                val = -val;
+            if (val === 0) {
+                writeUint(0, buf, pos + off0);
+                writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos + off1);
+            } else if (isNaN(val)) {
+                writeUint(0, buf, pos + off0);
+                writeUint(2146959360, buf, pos + off1);
+            } else if (val > 1.7976931348623157e+308) { // +-Infinity
+                writeUint(0, buf, pos + off0);
+                writeUint((sign << 31 | 2146435072) >>> 0, buf, pos + off1);
+            } else {
+                var mantissa;
+                if (val < 2.2250738585072014e-308) { // denormal
+                    mantissa = val / 5e-324;
+                    writeUint(mantissa >>> 0, buf, pos + off0);
+                    writeUint((sign << 31 | mantissa / 4294967296) >>> 0, buf, pos + off1);
+                } else {
+                    var exponent = Math.floor(Math.log(val) / Math.LN2);
+                    if (exponent === 1024)
+                        exponent = 1023;
+                    mantissa = val * Math.pow(2, -exponent);
+                    writeUint(mantissa * 4503599627370496 >>> 0, buf, pos + off0);
+                    writeUint((sign << 31 | exponent + 1023 << 20 | mantissa * 1048576 & 1048575) >>> 0, buf, pos + off1);
+                }
+            }
+        }
+
+        exports.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);
+        exports.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);
+
+        function readDouble_ieee754(readUint, off0, off1, buf, pos) {
+            var lo = readUint(buf, pos + off0),
+                hi = readUint(buf, pos + off1);
+            var sign = (hi >> 31) * 2 + 1,
+                exponent = hi >>> 20 & 2047,
+                mantissa = 4294967296 * (hi & 1048575) + lo;
+            return exponent === 2047
+                ? mantissa
+                ? NaN
+                : sign * Infinity
+                : exponent === 0 // denormal
+                ? sign * 5e-324 * mantissa
+                : sign * Math.pow(2, exponent - 1075) * (mantissa + 4503599627370496);
+        }
+
+        exports.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);
+        exports.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);
+
+    })();
+
+    return exports;
+}
+
+// uint helpers
+
+function writeUintLE(val, buf, pos) {
+    buf[pos    ] =  val        & 255;
+    buf[pos + 1] =  val >>> 8  & 255;
+    buf[pos + 2] =  val >>> 16 & 255;
+    buf[pos + 3] =  val >>> 24;
+}
+
+function writeUintBE(val, buf, pos) {
+    buf[pos    ] =  val >>> 24;
+    buf[pos + 1] =  val >>> 16 & 255;
+    buf[pos + 2] =  val >>> 8  & 255;
+    buf[pos + 3] =  val        & 255;
+}
+
+function readUintLE(buf, pos) {
+    return (buf[pos    ]
+          | buf[pos + 1] << 8
+          | buf[pos + 2] << 16
+          | buf[pos + 3] << 24) >>> 0;
+}
+
+function readUintBE(buf, pos) {
+    return (buf[pos    ] << 24
+          | buf[pos + 1] << 16
+          | buf[pos + 2] << 8
+          | buf[pos + 3]) >>> 0;
+}
 
-/**
- * Fetches the contents of a file.
- * @memberof util
- * @param {string} filename File path or url
- * @param {FetchOptions} options Fetch options
- * @param {FetchCallback} callback Callback function
- * @returns {undefined}
- */
-function fetch(filename, options, callback) {
-    if (typeof options === "function") {
-        callback = options;
-        options = {};
-    } else if (!options)
-        options = {};
 
-    if (!callback)
-        return asPromise(fetch, this, filename, options); // eslint-disable-line no-invalid-this
-
-    // if a node-like filesystem is present, try it first but fall back to XHR if nothing is found.
-    if (!options.xhr && fs && fs.readFile)
-        return fs.readFile(filename, function fetchReadFileCallback(err, contents) {
-            return err && typeof XMLHttpRequest !== "undefined"
-                ? fetch.xhr(filename, options, callback)
-                : err
-                ? callback(err)
-                : callback(null, options.binary ? contents : contents.toString("utf8"));
-        });
+/***/ }),
 
-    // use the XHR version otherwise.
-    return fetch.xhr(filename, options, callback);
-}
+/***/ 7199:
+/***/ ((module) => {
 
-/**
- * Fetches the contents of a file.
- * @name util.fetch
- * @function
- * @param {string} path File path or url
- * @param {FetchCallback} callback Callback function
- * @returns {undefined}
- * @variation 2
- */
+"use strict";
+
+module.exports = inquire;
+
+/**
+ * Requires a module only if available.
+ * @memberof util
+ * @param {string} moduleName Module to require
+ * @returns {?Object} Required module if available and not empty, otherwise `null`
+ */
+function inquire(moduleName) {
+    try {
+        var mod = eval("quire".replace(/^/,"re"))(moduleName); // eslint-disable-line no-eval
+        if (mod && (mod.length || Object.keys(mod).length))
+            return mod;
+    } catch (e) {} // eslint-disable-line no-empty
+    return null;
+}
 
-/**
- * Fetches the contents of a file.
- * @name util.fetch
- * @function
- * @param {string} path File path or url
- * @param {FetchOptions} [options] Fetch options
- * @returns {Promise<string|Uint8Array>} Promise
- * @variation 3
- */
 
-/**/
-fetch.xhr = function fetch_xhr(filename, options, callback) {
-    var xhr = new XMLHttpRequest();
-    xhr.onreadystatechange /* works everywhere */ = function fetchOnReadyStateChange() {
-
-        if (xhr.readyState !== 4)
-            return undefined;
-
-        // local cors security errors return status 0 / empty string, too. afaik this cannot be
-        // reliably distinguished from an actually empty file for security reasons. feel free
-        // to send a pull request if you are aware of a solution.
-        if (xhr.status !== 0 && xhr.status !== 200)
-            return callback(Error("status " + xhr.status));
-
-        // if binary data is expected, make sure that some sort of array is returned, even if
-        // ArrayBuffers are not supported. the binary string fallback, however, is unsafe.
-        if (options.binary) {
-            var buffer = xhr.response;
-            if (!buffer) {
-                buffer = [];
-                for (var i = 0; i < xhr.responseText.length; ++i)
-                    buffer.push(xhr.responseText.charCodeAt(i) & 255);
-            }
-            return callback(null, typeof Uint8Array !== "undefined" ? new Uint8Array(buffer) : buffer);
-        }
-        return callback(null, xhr.responseText);
-    };
+/***/ }),
 
-    if (options.binary) {
-        // ref: https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/Sending_and_Receiving_Binary_Data#Receiving_binary_data_in_older_browsers
-        if ("overrideMimeType" in xhr)
-            xhr.overrideMimeType("text/plain; charset=x-user-defined");
-        xhr.responseType = "arraybuffer";
-    }
+/***/ 8626:
+/***/ ((__unused_webpack_module, exports) => {
 
-    xhr.open("GET", filename);
-    xhr.send();
-};
+"use strict";
+
+
+/**
+ * A minimal path module to resolve Unix, Windows and URL paths alike.
+ * @memberof util
+ * @namespace
+ */
+var path = exports;
+
+var isAbsolute =
+/**
+ * Tests if the specified path is absolute.
+ * @param {string} path Path to test
+ * @returns {boolean} `true` if path is absolute
+ */
+path.isAbsolute = function isAbsolute(path) {
+    return /^(?:\/|\w+:)/.test(path);
+};
+
+var normalize =
+/**
+ * Normalizes the specified path.
+ * @param {string} path Path to normalize
+ * @returns {string} Normalized path
+ */
+path.normalize = function normalize(path) {
+    path = path.replace(/\\/g, "/")
+               .replace(/\/{2,}/g, "/");
+    var parts    = path.split("/"),
+        absolute = isAbsolute(path),
+        prefix   = "";
+    if (absolute)
+        prefix = parts.shift() + "/";
+    for (var i = 0; i < parts.length;) {
+        if (parts[i] === "..") {
+            if (i > 0 && parts[i - 1] !== "..")
+                parts.splice(--i, 2);
+            else if (absolute)
+                parts.splice(i, 1);
+            else
+                ++i;
+        } else if (parts[i] === ".")
+            parts.splice(i, 1);
+        else
+            ++i;
+    }
+    return prefix + parts.join("/");
+};
+
+/**
+ * Resolves the specified include path against the specified origin path.
+ * @param {string} originPath Path to the origin file
+ * @param {string} includePath Include path relative to origin path
+ * @param {boolean} [alreadyNormalized=false] `true` if both paths are already known to be normalized
+ * @returns {string} Path to the include file
+ */
+path.resolve = function resolve(originPath, includePath, alreadyNormalized) {
+    if (!alreadyNormalized)
+        includePath = normalize(includePath);
+    if (isAbsolute(includePath))
+        return includePath;
+    if (!alreadyNormalized)
+        originPath = normalize(originPath);
+    return (originPath = originPath.replace(/(?:\/|^)[^/]+$/, "")).length ? normalize(originPath + "/" + includePath) : includePath;
+};
 
 
 /***/ }),
 
-/***/ 945:
+/***/ 6662:
 /***/ ((module) => {
 
 "use strict";
+
+module.exports = pool;
+
+/**
+ * An allocator as used by {@link util.pool}.
+ * @typedef PoolAllocator
+ * @type {function}
+ * @param {number} size Buffer size
+ * @returns {Uint8Array} Buffer
+ */
+
+/**
+ * A slicer as used by {@link util.pool}.
+ * @typedef PoolSlicer
+ * @type {function}
+ * @param {number} start Start offset
+ * @param {number} end End offset
+ * @returns {Uint8Array} Buffer slice
+ * @this {Uint8Array}
+ */
+
+/**
+ * A general purpose buffer pool.
+ * @memberof util
+ * @function
+ * @param {PoolAllocator} alloc Allocator
+ * @param {PoolSlicer} slice Slicer
+ * @param {number} [size=8192] Slab size
+ * @returns {PoolAllocator} Pooled allocator
+ */
+function pool(alloc, slice, size) {
+    var SIZE   = size || 8192;
+    var MAX    = SIZE >>> 1;
+    var slab   = null;
+    var offset = SIZE;
+    return function pool_alloc(size) {
+        if (size < 1 || size > MAX)
+            return alloc(size);
+        if (offset + size > SIZE) {
+            slab = alloc(SIZE);
+            offset = 0;
+        }
+        var buf = slice.call(slab, offset, offset += size);
+        if (offset & 7) // align to 32 bit
+            offset = (offset | 7) + 1;
+        return buf;
+    };
+}
 
 
-module.exports = factory(factory);
+/***/ }),
 
-/**
- * Reads / writes floats / doubles from / to buffers.
- * @name util.float
- * @namespace
- */
+/***/ 4997:
+/***/ ((__unused_webpack_module, exports) => {
 
-/**
- * Writes a 32 bit float to a buffer using little endian byte order.
- * @name util.float.writeFloatLE
- * @function
- * @param {number} val Value to write
- * @param {Uint8Array} buf Target buffer
- * @param {number} pos Target buffer offset
- * @returns {undefined}
- */
+"use strict";
+
+
+/**
+ * A minimal UTF8 implementation for number arrays.
+ * @memberof util
+ * @namespace
+ */
+var utf8 = exports;
+
+/**
+ * Calculates the UTF8 byte length of a string.
+ * @param {string} string String
+ * @returns {number} Byte length
+ */
+utf8.length = function utf8_length(string) {
+    var len = 0,
+        c = 0;
+    for (var i = 0; i < string.length; ++i) {
+        c = string.charCodeAt(i);
+        if (c < 128)
+            len += 1;
+        else if (c < 2048)
+            len += 2;
+        else if ((c & 0xFC00) === 0xD800 && (string.charCodeAt(i + 1) & 0xFC00) === 0xDC00) {
+            ++i;
+            len += 4;
+        } else
+            len += 3;
+    }
+    return len;
+};
+
+/**
+ * Reads UTF8 bytes as a string.
+ * @param {Uint8Array} buffer Source buffer
+ * @param {number} start Source start
+ * @param {number} end Source end
+ * @returns {string} String read
+ */
+utf8.read = function utf8_read(buffer, start, end) {
+    var len = end - start;
+    if (len < 1)
+        return "";
+    var parts = null,
+        chunk = [],
+        i = 0, // char offset
+        t;     // temporary
+    while (start < end) {
+        t = buffer[start++];
+        if (t < 128)
+            chunk[i++] = t;
+        else if (t > 191 && t < 224)
+            chunk[i++] = (t & 31) << 6 | buffer[start++] & 63;
+        else if (t > 239 && t < 365) {
+            t = ((t & 7) << 18 | (buffer[start++] & 63) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63) - 0x10000;
+            chunk[i++] = 0xD800 + (t >> 10);
+            chunk[i++] = 0xDC00 + (t & 1023);
+        } else
+            chunk[i++] = (t & 15) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63;
+        if (i > 8191) {
+            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
+            i = 0;
+        }
+    }
+    if (parts) {
+        if (i)
+            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
+        return parts.join("");
+    }
+    return String.fromCharCode.apply(String, chunk.slice(0, i));
+};
+
+/**
+ * Writes a string as UTF8 bytes.
+ * @param {string} string Source string
+ * @param {Uint8Array} buffer Destination buffer
+ * @param {number} offset Destination offset
+ * @returns {number} Bytes written
+ */
+utf8.write = function utf8_write(string, buffer, offset) {
+    var start = offset,
+        c1, // character 1
+        c2; // character 2
+    for (var i = 0; i < string.length; ++i) {
+        c1 = string.charCodeAt(i);
+        if (c1 < 128) {
+            buffer[offset++] = c1;
+        } else if (c1 < 2048) {
+            buffer[offset++] = c1 >> 6       | 192;
+            buffer[offset++] = c1       & 63 | 128;
+        } else if ((c1 & 0xFC00) === 0xD800 && ((c2 = string.charCodeAt(i + 1)) & 0xFC00) === 0xDC00) {
+            c1 = 0x10000 + ((c1 & 0x03FF) << 10) + (c2 & 0x03FF);
+            ++i;
+            buffer[offset++] = c1 >> 18      | 240;
+            buffer[offset++] = c1 >> 12 & 63 | 128;
+            buffer[offset++] = c1 >> 6  & 63 | 128;
+            buffer[offset++] = c1       & 63 | 128;
+        } else {
+            buffer[offset++] = c1 >> 12      | 224;
+            buffer[offset++] = c1 >> 6  & 63 | 128;
+            buffer[offset++] = c1       & 63 | 128;
+        }
+    }
+    return offset - start;
+};
 
-/**
- * Writes a 32 bit float to a buffer using big endian byte order.
- * @name util.float.writeFloatBE
- * @function
- * @param {number} val Value to write
- * @param {Uint8Array} buf Target buffer
- * @param {number} pos Target buffer offset
- * @returns {undefined}
- */
 
-/**
- * Reads a 32 bit float from a buffer using little endian byte order.
- * @name util.float.readFloatLE
- * @function
- * @param {Uint8Array} buf Source buffer
- * @param {number} pos Source buffer offset
- * @returns {number} Value read
- */
+/***/ }),
 
-/**
- * Reads a 32 bit float from a buffer using big endian byte order.
- * @name util.float.readFloatBE
- * @function
- * @param {Uint8Array} buf Source buffer
- * @param {number} pos Source buffer offset
- * @returns {number} Value read
- */
+/***/ 9669:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * Writes a 64 bit double to a buffer using little endian byte order.
- * @name util.float.writeDoubleLE
- * @function
- * @param {number} val Value to write
- * @param {Uint8Array} buf Target buffer
- * @param {number} pos Target buffer offset
- * @returns {undefined}
- */
+module.exports = __webpack_require__(1609);
 
-/**
- * Writes a 64 bit double to a buffer using big endian byte order.
- * @name util.float.writeDoubleBE
- * @function
- * @param {number} val Value to write
- * @param {Uint8Array} buf Target buffer
- * @param {number} pos Target buffer offset
- * @returns {undefined}
- */
+/***/ }),
 
-/**
- * Reads a 64 bit double from a buffer using little endian byte order.
- * @name util.float.readDoubleLE
- * @function
- * @param {Uint8Array} buf Source buffer
- * @param {number} pos Source buffer offset
- * @returns {number} Value read
- */
+/***/ 5448:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/**
- * Reads a 64 bit double from a buffer using big endian byte order.
- * @name util.float.readDoubleBE
- * @function
- * @param {Uint8Array} buf Source buffer
- * @param {number} pos Source buffer offset
- * @returns {number} Value read
- */
+"use strict";
 
-// Factory function for the purpose of node-based testing in modified global environments
-function factory(exports) {
 
-    // float: typed array
-    if (typeof Float32Array !== "undefined") (function() {
+var utils = __webpack_require__(4867);
+var settle = __webpack_require__(6026);
+var cookies = __webpack_require__(4372);
+var buildURL = __webpack_require__(5327);
+var buildFullPath = __webpack_require__(4097);
+var parseHeaders = __webpack_require__(4109);
+var isURLSameOrigin = __webpack_require__(7985);
+var createError = __webpack_require__(5061);
 
-        var f32 = new Float32Array([ -0 ]),
-            f8b = new Uint8Array(f32.buffer),
-            le  = f8b[3] === 128;
+module.exports = function xhrAdapter(config) {
+  return new Promise(function dispatchXhrRequest(resolve, reject) {
+    var requestData = config.data;
+    var requestHeaders = config.headers;
 
-        function writeFloat_f32_cpy(val, buf, pos) {
-            f32[0] = val;
-            buf[pos    ] = f8b[0];
-            buf[pos + 1] = f8b[1];
-            buf[pos + 2] = f8b[2];
-            buf[pos + 3] = f8b[3];
-        }
+    if (utils.isFormData(requestData)) {
+      delete requestHeaders['Content-Type']; // Let the browser set it
+    }
 
-        function writeFloat_f32_rev(val, buf, pos) {
-            f32[0] = val;
-            buf[pos    ] = f8b[3];
-            buf[pos + 1] = f8b[2];
-            buf[pos + 2] = f8b[1];
-            buf[pos + 3] = f8b[0];
-        }
+    var request = new XMLHttpRequest();
 
-        /* istanbul ignore next */
-        exports.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;
-        /* istanbul ignore next */
-        exports.writeFloatBE = le ? writeFloat_f32_rev : writeFloat_f32_cpy;
-
-        function readFloat_f32_cpy(buf, pos) {
-            f8b[0] = buf[pos    ];
-            f8b[1] = buf[pos + 1];
-            f8b[2] = buf[pos + 2];
-            f8b[3] = buf[pos + 3];
-            return f32[0];
-        }
+    // HTTP basic authentication
+    if (config.auth) {
+      var username = config.auth.username || '';
+      var password = config.auth.password ? unescape(encodeURIComponent(config.auth.password)) : '';
+      requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password);
+    }
 
-        function readFloat_f32_rev(buf, pos) {
-            f8b[3] = buf[pos    ];
-            f8b[2] = buf[pos + 1];
-            f8b[1] = buf[pos + 2];
-            f8b[0] = buf[pos + 3];
-            return f32[0];
-        }
+    var fullPath = buildFullPath(config.baseURL, config.url);
+    request.open(config.method.toUpperCase(), buildURL(fullPath, config.params, config.paramsSerializer), true);
 
-        /* istanbul ignore next */
-        exports.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;
-        /* istanbul ignore next */
-        exports.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;
-
-    // float: ieee754
-    })(); else (function() {
-
-        function writeFloat_ieee754(writeUint, val, buf, pos) {
-            var sign = val < 0 ? 1 : 0;
-            if (sign)
-                val = -val;
-            if (val === 0)
-                writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos);
-            else if (isNaN(val))
-                writeUint(2143289344, buf, pos);
-            else if (val > 3.4028234663852886e+38) // +-Infinity
-                writeUint((sign << 31 | 2139095040) >>> 0, buf, pos);
-            else if (val < 1.1754943508222875e-38) // denormal
-                writeUint((sign << 31 | Math.round(val / 1.401298464324817e-45)) >>> 0, buf, pos);
-            else {
-                var exponent = Math.floor(Math.log(val) / Math.LN2),
-                    mantissa = Math.round(val * Math.pow(2, -exponent) * 8388608) & 8388607;
-                writeUint((sign << 31 | exponent + 127 << 23 | mantissa) >>> 0, buf, pos);
-            }
-        }
-
-        exports.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);
-        exports.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);
-
-        function readFloat_ieee754(readUint, buf, pos) {
-            var uint = readUint(buf, pos),
-                sign = (uint >> 31) * 2 + 1,
-                exponent = uint >>> 23 & 255,
-                mantissa = uint & 8388607;
-            return exponent === 255
-                ? mantissa
-                ? NaN
-                : sign * Infinity
-                : exponent === 0 // denormal
-                ? sign * 1.401298464324817e-45 * mantissa
-                : sign * Math.pow(2, exponent - 150) * (mantissa + 8388608);
-        }
-
-        exports.readFloatLE = readFloat_ieee754.bind(null, readUintLE);
-        exports.readFloatBE = readFloat_ieee754.bind(null, readUintBE);
-
-    })();
-
-    // double: typed array
-    if (typeof Float64Array !== "undefined") (function() {
-
-        var f64 = new Float64Array([-0]),
-            f8b = new Uint8Array(f64.buffer),
-            le  = f8b[7] === 128;
-
-        function writeDouble_f64_cpy(val, buf, pos) {
-            f64[0] = val;
-            buf[pos    ] = f8b[0];
-            buf[pos + 1] = f8b[1];
-            buf[pos + 2] = f8b[2];
-            buf[pos + 3] = f8b[3];
-            buf[pos + 4] = f8b[4];
-            buf[pos + 5] = f8b[5];
-            buf[pos + 6] = f8b[6];
-            buf[pos + 7] = f8b[7];
-        }
-
-        function writeDouble_f64_rev(val, buf, pos) {
-            f64[0] = val;
-            buf[pos    ] = f8b[7];
-            buf[pos + 1] = f8b[6];
-            buf[pos + 2] = f8b[5];
-            buf[pos + 3] = f8b[4];
-            buf[pos + 4] = f8b[3];
-            buf[pos + 5] = f8b[2];
-            buf[pos + 6] = f8b[1];
-            buf[pos + 7] = f8b[0];
-        }
-
-        /* istanbul ignore next */
-        exports.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;
-        /* istanbul ignore next */
-        exports.writeDoubleBE = le ? writeDouble_f64_rev : writeDouble_f64_cpy;
-
-        function readDouble_f64_cpy(buf, pos) {
-            f8b[0] = buf[pos    ];
-            f8b[1] = buf[pos + 1];
-            f8b[2] = buf[pos + 2];
-            f8b[3] = buf[pos + 3];
-            f8b[4] = buf[pos + 4];
-            f8b[5] = buf[pos + 5];
-            f8b[6] = buf[pos + 6];
-            f8b[7] = buf[pos + 7];
-            return f64[0];
-        }
-
-        function readDouble_f64_rev(buf, pos) {
-            f8b[7] = buf[pos    ];
-            f8b[6] = buf[pos + 1];
-            f8b[5] = buf[pos + 2];
-            f8b[4] = buf[pos + 3];
-            f8b[3] = buf[pos + 4];
-            f8b[2] = buf[pos + 5];
-            f8b[1] = buf[pos + 6];
-            f8b[0] = buf[pos + 7];
-            return f64[0];
-        }
-
-        /* istanbul ignore next */
-        exports.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;
-        /* istanbul ignore next */
-        exports.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;
-
-    // double: ieee754
-    })(); else (function() {
-
-        function writeDouble_ieee754(writeUint, off0, off1, val, buf, pos) {
-            var sign = val < 0 ? 1 : 0;
-            if (sign)
-                val = -val;
-            if (val === 0) {
-                writeUint(0, buf, pos + off0);
-                writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos + off1);
-            } else if (isNaN(val)) {
-                writeUint(0, buf, pos + off0);
-                writeUint(2146959360, buf, pos + off1);
-            } else if (val > 1.7976931348623157e+308) { // +-Infinity
-                writeUint(0, buf, pos + off0);
-                writeUint((sign << 31 | 2146435072) >>> 0, buf, pos + off1);
-            } else {
-                var mantissa;
-                if (val < 2.2250738585072014e-308) { // denormal
-                    mantissa = val / 5e-324;
-                    writeUint(mantissa >>> 0, buf, pos + off0);
-                    writeUint((sign << 31 | mantissa / 4294967296) >>> 0, buf, pos + off1);
-                } else {
-                    var exponent = Math.floor(Math.log(val) / Math.LN2);
-                    if (exponent === 1024)
-                        exponent = 1023;
-                    mantissa = val * Math.pow(2, -exponent);
-                    writeUint(mantissa * 4503599627370496 >>> 0, buf, pos + off0);
-                    writeUint((sign << 31 | exponent + 1023 << 20 | mantissa * 1048576 & 1048575) >>> 0, buf, pos + off1);
-                }
-            }
-        }
-
-        exports.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);
-        exports.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);
-
-        function readDouble_ieee754(readUint, off0, off1, buf, pos) {
-            var lo = readUint(buf, pos + off0),
-                hi = readUint(buf, pos + off1);
-            var sign = (hi >> 31) * 2 + 1,
-                exponent = hi >>> 20 & 2047,
-                mantissa = 4294967296 * (hi & 1048575) + lo;
-            return exponent === 2047
-                ? mantissa
-                ? NaN
-                : sign * Infinity
-                : exponent === 0 // denormal
-                ? sign * 5e-324 * mantissa
-                : sign * Math.pow(2, exponent - 1075) * (mantissa + 4503599627370496);
-        }
-
-        exports.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);
-        exports.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);
-
-    })();
-
-    return exports;
-}
-
-// uint helpers
-
-function writeUintLE(val, buf, pos) {
-    buf[pos    ] =  val        & 255;
-    buf[pos + 1] =  val >>> 8  & 255;
-    buf[pos + 2] =  val >>> 16 & 255;
-    buf[pos + 3] =  val >>> 24;
-}
-
-function writeUintBE(val, buf, pos) {
-    buf[pos    ] =  val >>> 24;
-    buf[pos + 1] =  val >>> 16 & 255;
-    buf[pos + 2] =  val >>> 8  & 255;
-    buf[pos + 3] =  val        & 255;
-}
-
-function readUintLE(buf, pos) {
-    return (buf[pos    ]
-          | buf[pos + 1] << 8
-          | buf[pos + 2] << 16
-          | buf[pos + 3] << 24) >>> 0;
-}
-
-function readUintBE(buf, pos) {
-    return (buf[pos    ] << 24
-          | buf[pos + 1] << 16
-          | buf[pos + 2] << 8
-          | buf[pos + 3]) >>> 0;
-}
-
-
-/***/ }),
-
-/***/ 7199:
-/***/ ((module) => {
-
-"use strict";
-
-module.exports = inquire;
-
-/**
- * Requires a module only if available.
- * @memberof util
- * @param {string} moduleName Module to require
- * @returns {?Object} Required module if available and not empty, otherwise `null`
- */
-function inquire(moduleName) {
-    try {
-        var mod = eval("quire".replace(/^/,"re"))(moduleName); // eslint-disable-line no-eval
-        if (mod && (mod.length || Object.keys(mod).length))
-            return mod;
-    } catch (e) {} // eslint-disable-line no-empty
-    return null;
-}
-
-
-/***/ }),
-
-/***/ 8626:
-/***/ ((__unused_webpack_module, exports) => {
-
-"use strict";
-
-
-/**
- * A minimal path module to resolve Unix, Windows and URL paths alike.
- * @memberof util
- * @namespace
- */
-var path = exports;
-
-var isAbsolute =
-/**
- * Tests if the specified path is absolute.
- * @param {string} path Path to test
- * @returns {boolean} `true` if path is absolute
- */
-path.isAbsolute = function isAbsolute(path) {
-    return /^(?:\/|\w+:)/.test(path);
-};
-
-var normalize =
-/**
- * Normalizes the specified path.
- * @param {string} path Path to normalize
- * @returns {string} Normalized path
- */
-path.normalize = function normalize(path) {
-    path = path.replace(/\\/g, "/")
-               .replace(/\/{2,}/g, "/");
-    var parts    = path.split("/"),
-        absolute = isAbsolute(path),
-        prefix   = "";
-    if (absolute)
-        prefix = parts.shift() + "/";
-    for (var i = 0; i < parts.length;) {
-        if (parts[i] === "..") {
-            if (i > 0 && parts[i - 1] !== "..")
-                parts.splice(--i, 2);
-            else if (absolute)
-                parts.splice(i, 1);
-            else
-                ++i;
-        } else if (parts[i] === ".")
-            parts.splice(i, 1);
-        else
-            ++i;
-    }
-    return prefix + parts.join("/");
-};
-
-/**
- * Resolves the specified include path against the specified origin path.
- * @param {string} originPath Path to the origin file
- * @param {string} includePath Include path relative to origin path
- * @param {boolean} [alreadyNormalized=false] `true` if both paths are already known to be normalized
- * @returns {string} Path to the include file
- */
-path.resolve = function resolve(originPath, includePath, alreadyNormalized) {
-    if (!alreadyNormalized)
-        includePath = normalize(includePath);
-    if (isAbsolute(includePath))
-        return includePath;
-    if (!alreadyNormalized)
-        originPath = normalize(originPath);
-    return (originPath = originPath.replace(/(?:\/|^)[^/]+$/, "")).length ? normalize(originPath + "/" + includePath) : includePath;
-};
-
-
-/***/ }),
-
-/***/ 6662:
-/***/ ((module) => {
-
-"use strict";
-
-module.exports = pool;
-
-/**
- * An allocator as used by {@link util.pool}.
- * @typedef PoolAllocator
- * @type {function}
- * @param {number} size Buffer size
- * @returns {Uint8Array} Buffer
- */
-
-/**
- * A slicer as used by {@link util.pool}.
- * @typedef PoolSlicer
- * @type {function}
- * @param {number} start Start offset
- * @param {number} end End offset
- * @returns {Uint8Array} Buffer slice
- * @this {Uint8Array}
- */
-
-/**
- * A general purpose buffer pool.
- * @memberof util
- * @function
- * @param {PoolAllocator} alloc Allocator
- * @param {PoolSlicer} slice Slicer
- * @param {number} [size=8192] Slab size
- * @returns {PoolAllocator} Pooled allocator
- */
-function pool(alloc, slice, size) {
-    var SIZE   = size || 8192;
-    var MAX    = SIZE >>> 1;
-    var slab   = null;
-    var offset = SIZE;
-    return function pool_alloc(size) {
-        if (size < 1 || size > MAX)
-            return alloc(size);
-        if (offset + size > SIZE) {
-            slab = alloc(SIZE);
-            offset = 0;
-        }
-        var buf = slice.call(slab, offset, offset += size);
-        if (offset & 7) // align to 32 bit
-            offset = (offset | 7) + 1;
-        return buf;
-    };
-}
-
-
-/***/ }),
-
-/***/ 4997:
-/***/ ((__unused_webpack_module, exports) => {
-
-"use strict";
-
-
-/**
- * A minimal UTF8 implementation for number arrays.
- * @memberof util
- * @namespace
- */
-var utf8 = exports;
-
-/**
- * Calculates the UTF8 byte length of a string.
- * @param {string} string String
- * @returns {number} Byte length
- */
-utf8.length = function utf8_length(string) {
-    var len = 0,
-        c = 0;
-    for (var i = 0; i < string.length; ++i) {
-        c = string.charCodeAt(i);
-        if (c < 128)
-            len += 1;
-        else if (c < 2048)
-            len += 2;
-        else if ((c & 0xFC00) === 0xD800 && (string.charCodeAt(i + 1) & 0xFC00) === 0xDC00) {
-            ++i;
-            len += 4;
-        } else
-            len += 3;
-    }
-    return len;
-};
-
-/**
- * Reads UTF8 bytes as a string.
- * @param {Uint8Array} buffer Source buffer
- * @param {number} start Source start
- * @param {number} end Source end
- * @returns {string} String read
- */
-utf8.read = function utf8_read(buffer, start, end) {
-    var len = end - start;
-    if (len < 1)
-        return "";
-    var parts = null,
-        chunk = [],
-        i = 0, // char offset
-        t;     // temporary
-    while (start < end) {
-        t = buffer[start++];
-        if (t < 128)
-            chunk[i++] = t;
-        else if (t > 191 && t < 224)
-            chunk[i++] = (t & 31) << 6 | buffer[start++] & 63;
-        else if (t > 239 && t < 365) {
-            t = ((t & 7) << 18 | (buffer[start++] & 63) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63) - 0x10000;
-            chunk[i++] = 0xD800 + (t >> 10);
-            chunk[i++] = 0xDC00 + (t & 1023);
-        } else
-            chunk[i++] = (t & 15) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63;
-        if (i > 8191) {
-            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
-            i = 0;
-        }
-    }
-    if (parts) {
-        if (i)
-            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
-        return parts.join("");
-    }
-    return String.fromCharCode.apply(String, chunk.slice(0, i));
-};
-
-/**
- * Writes a string as UTF8 bytes.
- * @param {string} string Source string
- * @param {Uint8Array} buffer Destination buffer
- * @param {number} offset Destination offset
- * @returns {number} Bytes written
- */
-utf8.write = function utf8_write(string, buffer, offset) {
-    var start = offset,
-        c1, // character 1
-        c2; // character 2
-    for (var i = 0; i < string.length; ++i) {
-        c1 = string.charCodeAt(i);
-        if (c1 < 128) {
-            buffer[offset++] = c1;
-        } else if (c1 < 2048) {
-            buffer[offset++] = c1 >> 6       | 192;
-            buffer[offset++] = c1       & 63 | 128;
-        } else if ((c1 & 0xFC00) === 0xD800 && ((c2 = string.charCodeAt(i + 1)) & 0xFC00) === 0xDC00) {
-            c1 = 0x10000 + ((c1 & 0x03FF) << 10) + (c2 & 0x03FF);
-            ++i;
-            buffer[offset++] = c1 >> 18      | 240;
-            buffer[offset++] = c1 >> 12 & 63 | 128;
-            buffer[offset++] = c1 >> 6  & 63 | 128;
-            buffer[offset++] = c1       & 63 | 128;
-        } else {
-            buffer[offset++] = c1 >> 12      | 224;
-            buffer[offset++] = c1 >> 6  & 63 | 128;
-            buffer[offset++] = c1       & 63 | 128;
-        }
-    }
-    return offset - start;
-};
-
-
-/***/ }),
-
-/***/ 9669:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-module.exports = __webpack_require__(1609);
-
-/***/ }),
-
-/***/ 5448:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-"use strict";
-
-
-var utils = __webpack_require__(4867);
-var settle = __webpack_require__(6026);
-var cookies = __webpack_require__(4372);
-var buildURL = __webpack_require__(5327);
-var buildFullPath = __webpack_require__(4097);
-var parseHeaders = __webpack_require__(4109);
-var isURLSameOrigin = __webpack_require__(7985);
-var createError = __webpack_require__(5061);
-
-module.exports = function xhrAdapter(config) {
-  return new Promise(function dispatchXhrRequest(resolve, reject) {
-    var requestData = config.data;
-    var requestHeaders = config.headers;
-
-    if (utils.isFormData(requestData)) {
-      delete requestHeaders['Content-Type']; // Let the browser set it
-    }
-
-    var request = new XMLHttpRequest();
-
-    // HTTP basic authentication
-    if (config.auth) {
-      var username = config.auth.username || '';
-      var password = config.auth.password ? unescape(encodeURIComponent(config.auth.password)) : '';
-      requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password);
-    }
-
-    var fullPath = buildFullPath(config.baseURL, config.url);
-    request.open(config.method.toUpperCase(), buildURL(fullPath, config.params, config.paramsSerializer), true);
-
-    // Set the request timeout in MS
-    request.timeout = config.timeout;
+    // Set the request timeout in MS
+    request.timeout = config.timeout;
 
     // Listen for ready state
     request.onreadystatechange = function handleLoad() {
@@ -11372,303 +11372,303 @@ BufferWriter._configure();
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.Contract = void 0;
-const Serializer_1 = __webpack_require__(7187);
-const utils_1 = __webpack_require__(8593);
-/**
- * The contract class contains the contract ID and contract entries
- * definition needed to encode/decode operations during the
- * interaction with the user and the communication with the RPC node.
- *
- * @example
- *
- * ```ts
- * const { Contract, Provider, Signer, utils } = require("koilib");
- * const rpcNodes = ["http://api.koinos.io:8080"];
- * const privateKey = "f186a5de49797bfd52dc42505c33d75a46822ed5b60046e09d7c336242e20200";
- * const provider = new Provider(rpcNodes);
- * const signer = new Signer({ privateKey, provider });
- * const koinContract = new Contract({
- *   id: "19JntSm8pSNETT9aHTwAUHC5RMoaSmgZPJ",
- *   abi: utils.Krc20Abi,
- *   provider,
- *   signer,
- * });
- * const koin = koinContract.functions;
- *
- * // optional: preformat input/output
- * koinContract.abi.methods.balanceOf.preformatInput = (owner) =>
- *   ({ owner });
- * koinContract.abi.methods.balanceOf.preformatOutput = (res) =>
- *   utils.formatUnits(res.value, 8);
- * koinContract.abi.methods.transfer.preformatInput = (input) => ({
- *   from: signer.getAddress(),
- *   to: input.to,
- *   value: utils.parseUnits(input.value, 8),
- * });
- *
- * async funtion main() {
- *   // Get balance
- *   const { result } = await koin.balanceOf("12fN2CQnuJM8cMnWZ1hPtM4knjLME8E4PD");
- *   console.log(result)
- *
- *   // Transfer
- *   const { transaction, transactionResponse } = await koin.transfer({
- *     to: "172AB1FgCsYrRAW5cwQ8KjadgxofvgPFd6",
- *     value: "10.0001",
- *   });
- *   console.log(`Transaction id ${transaction.id} submitted`);
- *
- *   // wait to be mined
- *   const blockId = await transactionResponse.wait();
- *   console.log(`Transaction mined. Block id: ${blockId}`);
- * }
- *
- * main();
- * ```
- */
-class Contract {
-    constructor(c) {
-        var _a;
-        if (c.id)
-            this.id = utils_1.decodeBase58(c.id);
-        this.signer = c.signer;
-        this.provider = c.provider || ((_a = c.signer) === null || _a === void 0 ? void 0 : _a.provider);
-        this.abi = c.abi;
-        this.bytecode = c.bytecode;
-        if (c.serializer) {
-            this.serializer = c.serializer;
-        }
-        else if (c.abi && c.abi.types) {
-            this.serializer = new Serializer_1.Serializer(c.abi.types);
-        }
-        this.options = {
-            rc_limit: 1e8,
-            sendTransaction: true,
-            sendAbis: true,
-            ...c.options,
-        };
-        this.functions = {};
-        if (this.signer &&
-            this.provider &&
-            this.abi &&
-            this.abi.methods &&
-            this.serializer) {
-            Object.keys(this.abi.methods).forEach((name) => {
-                this.functions[name] = async (argu = {}, options) => {
-                    if (!this.provider)
-                        throw new Error("provider not found");
-                    if (!this.abi || !this.abi.methods)
-                        throw new Error("Methods are not defined");
-                    if (!this.abi.methods[name])
-                        throw new Error(`Method ${name} not defined in the ABI`);
-                    const opts = {
-                        ...this.options,
-                        ...options,
-                    };
-                    const { readOnly, output, defaultOutput, preformatInput, preformatOutput, } = this.abi.methods[name];
-                    let args;
-                    if (typeof preformatInput === "function") {
-                        args = preformatInput(argu);
-                    }
-                    else {
-                        args = argu;
-                    }
-                    const operation = await this.encodeOperation({ name, args });
-                    if (readOnly) {
-                        if (!output)
-                            throw new Error(`No output defined for ${name}`);
-                        // read contract
-                        const { result: resultEncoded } = await this.provider.readContract({
-                            contract_id: utils_1.encodeBase58(operation.call_contract.contract_id),
-                            entry_point: operation.call_contract.entry_point,
-                            args: utils_1.encodeBase64(operation.call_contract.args),
-                        });
-                        let result = defaultOutput;
-                        if (resultEncoded) {
-                            result = await this.serializer.deserialize(resultEncoded, output);
-                        }
-                        if (typeof preformatOutput === "function") {
-                            result = preformatOutput(result);
-                        }
-                        return { operation, result };
-                    }
-                    // return operation if send is false
-                    if (!(opts === null || opts === void 0 ? void 0 : opts.sendTransaction))
-                        return { operation };
-                    // write contract (sign and send)
-                    if (!this.signer)
-                        throw new Error("signer not found");
-                    const transaction = await this.signer.encodeTransaction({
-                        ...opts,
-                        operations: [operation],
-                    });
-                    const abis = {};
-                    if (opts === null || opts === void 0 ? void 0 : opts.sendAbis) {
-                        const contractId = utils_1.encodeBase58(this.id);
-                        abis[contractId] = this.abi;
-                    }
-                    const transactionResponse = await this.signer.sendTransaction(transaction, abis);
-                    return { operation, transaction, transactionResponse };
-                };
-            });
-        }
-    }
-    /**
-     * Compute contract Id
-     */
-    static computeContractId(address) {
-        return utils_1.decodeBase58(address);
-    }
-    /**
-     * Get contract Id
-     */
-    getId() {
-        if (!this.id)
-            throw new Error("id is not defined");
-        return utils_1.encodeBase58(this.id);
-    }
-    /**
-     * Function to deploy a new smart contract.
-     * The Bytecode must be defined in the constructor of the class
-     * @example
-     * ```ts
-     * const privateKey = "f186a5de49797bfd52dc42505c33d75a46822ed5b60046e09d7c336242e20200";
-     * const provider = new Provider(["http://api.koinos.io:8080"]);
-     * const signer = new Signer({ privateKey, provider });
-     * const bytecode = new Uint8Array([1, 2, 3, 4]);
-     * const contract = new Contract({ signer, provider, bytecode });
-     * const { transactionResponse } = await contract.deploy();
-     * // wait to be mined
-     * const blockId = await transactionResponse.wait();
-     * console.log(`Contract uploaded in block id ${blockId}`);
-     * ```
-     */
-    async deploy(options) {
-        if (!this.signer)
-            throw new Error("signer not found");
-        if (!this.bytecode)
-            throw new Error("bytecode not found");
-        const opts = {
-            ...this.options,
-            ...options,
-        };
-        const operation = {
-            upload_contract: {
-                contract_id: Contract.computeContractId(this.signer.getAddress()),
-                bytecode: this.bytecode,
-            },
-        };
-        // return operation if send is false
-        if (!(opts === null || opts === void 0 ? void 0 : opts.sendTransaction))
-            return { operation };
-        const transaction = await this.signer.encodeTransaction({
-            ...opts,
-            operations: [operation],
-        });
-        const transactionResponse = await this.signer.sendTransaction(transaction);
-        return { operation, transaction, transactionResponse };
-    }
-    /**
-     * Encondes a contract operation using Koinos serialization
-     * and taking the contract entries as reference to build it
-     * @param op - Operation to encode
-     * @returns Operation encoded
-     * @example
-     * ```ts
-     * const opEncoded = contract.encodeOperation({
-     *   name: "transfer",
-     *   args: {
-     *     from: "12fN2CQnuJM8cMnWZ1hPtM4knjLME8E4PD",
-     *     to: "172AB1FgCsYrRAW5cwQ8KjadgxofvgPFd6",
-     *     value: "1000",
-     *   }
-     * });
-     *
-     * console.log(opEncoded);
-     * // {
-     * //   call_contract: {
-     * //     contract_id: "19JntSm8pSNETT9aHTwAUHC5RMoaSmgZPJ",
-     * //     entry_point: 0x62efa292,
-     * //     args: "MBWFsaWNlA2JvYgAAAAAAAAPo",
-     * //   }
-     * // }
-     * ```
-     */
-    async encodeOperation(op) {
-        if (!this.abi || !this.abi.methods || !this.abi.methods[op.name])
-            throw new Error(`Operation ${op.name} unknown`);
-        if (!this.serializer)
-            throw new Error("Serializer is not defined");
-        if (!this.id)
-            throw new Error("Contract id is not defined");
-        const method = this.abi.methods[op.name];
-        let bufferInputs = new Uint8Array(0);
-        if (method.input) {
-            if (!op.args)
-                throw new Error(`No arguments defined for type '${method.input}'`);
-            bufferInputs = await this.serializer.serialize(op.args, method.input);
-        }
-        return {
-            call_contract: {
-                contract_id: this.id,
-                entry_point: method.entryPoint,
-                args: bufferInputs,
-            },
-        };
-    }
-    /**
-     * Decodes a contract operation to be human readable
-     * @example
-     * ```ts
-     * const opDecoded = contract.decodeOperation({
-     *   call_contract: {
-     *     contract_id: "19JntSm8pSNETT9aHTwAUHC5RMoaSmgZPJ",
-     *     entry_point: 0x62efa292,
-     *     args: "MBWFsaWNlA2JvYgAAAAAAAAPo",
-     *   }
-     * });
-     * console.log(opDecoded);
-     * // {
-     * //   name: "transfer",
-     * //   args: {
-     * //     from: "12fN2CQnuJM8cMnWZ1hPtM4knjLME8E4PD",
-     * //     to: "172AB1FgCsYrRAW5cwQ8KjadgxofvgPFd6",
-     * //     value: "1000",
-     * //   },
-     * // }
-     * ```
-     */
-    async decodeOperation(op) {
-        if (!this.id)
-            throw new Error("Contract id is not defined");
-        if (!this.abi || !this.abi.methods)
-            throw new Error("Methods are not defined");
-        if (!this.serializer)
-            throw new Error("Serializer is not defined");
-        if (!op.call_contract)
-            throw new Error("Operation is not CallContractOperation");
-        if (op.call_contract.contract_id !== this.id)
-            throw new Error(`Invalid contract id. Expected: ${utils_1.encodeBase58(this.id)}. Received: ${utils_1.encodeBase58(op.call_contract.contract_id)}`);
-        for (let i = 0; i < Object.keys(this.abi.methods).length; i += 1) {
-            const opName = Object.keys(this.abi.methods)[i];
-            const method = this.abi.methods[opName];
-            if (op.call_contract.entry_point === method.entryPoint) {
-                if (!method.input)
-                    return { name: opName };
-                return {
-                    name: opName,
-                    args: await this.serializer.deserialize(op.call_contract.args, method.input),
-                };
-            }
-        }
-        throw new Error(`Unknown method id ${op.call_contract.entry_point}`);
-    }
-}
-exports.Contract = Contract;
-exports.default = Contract;
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.Contract = void 0;
+const Serializer_1 = __webpack_require__(7187);
+const utils_1 = __webpack_require__(8593);
+/**
+ * The contract class contains the contract ID and contract entries
+ * definition needed to encode/decode operations during the
+ * interaction with the user and the communication with the RPC node.
+ *
+ * @example
+ *
+ * ```ts
+ * const { Contract, Provider, Signer, utils } = require("koilib");
+ * const rpcNodes = ["http://api.koinos.io:8080"];
+ * const privateKey = "f186a5de49797bfd52dc42505c33d75a46822ed5b60046e09d7c336242e20200";
+ * const provider = new Provider(rpcNodes);
+ * const signer = new Signer({ privateKey, provider });
+ * const koinContract = new Contract({
+ *   id: "19JntSm8pSNETT9aHTwAUHC5RMoaSmgZPJ",
+ *   abi: utils.Krc20Abi,
+ *   provider,
+ *   signer,
+ * });
+ * const koin = koinContract.functions;
+ *
+ * // optional: preformat input/output
+ * koinContract.abi.methods.balanceOf.preformatInput = (owner) =>
+ *   ({ owner });
+ * koinContract.abi.methods.balanceOf.preformatOutput = (res) =>
+ *   utils.formatUnits(res.value, 8);
+ * koinContract.abi.methods.transfer.preformatInput = (input) => ({
+ *   from: signer.getAddress(),
+ *   to: input.to,
+ *   value: utils.parseUnits(input.value, 8),
+ * });
+ *
+ * async funtion main() {
+ *   // Get balance
+ *   const { result } = await koin.balanceOf("12fN2CQnuJM8cMnWZ1hPtM4knjLME8E4PD");
+ *   console.log(result)
+ *
+ *   // Transfer
+ *   const { transaction, transactionResponse } = await koin.transfer({
+ *     to: "172AB1FgCsYrRAW5cwQ8KjadgxofvgPFd6",
+ *     value: "10.0001",
+ *   });
+ *   console.log(`Transaction id ${transaction.id} submitted`);
+ *
+ *   // wait to be mined
+ *   const blockId = await transactionResponse.wait();
+ *   console.log(`Transaction mined. Block id: ${blockId}`);
+ * }
+ *
+ * main();
+ * ```
+ */
+class Contract {
+    constructor(c) {
+        var _a;
+        if (c.id)
+            this.id = utils_1.decodeBase58(c.id);
+        this.signer = c.signer;
+        this.provider = c.provider || ((_a = c.signer) === null || _a === void 0 ? void 0 : _a.provider);
+        this.abi = c.abi;
+        this.bytecode = c.bytecode;
+        if (c.serializer) {
+            this.serializer = c.serializer;
+        }
+        else if (c.abi && c.abi.types) {
+            this.serializer = new Serializer_1.Serializer(c.abi.types);
+        }
+        this.options = {
+            rc_limit: 1e8,
+            sendTransaction: true,
+            sendAbis: true,
+            ...c.options,
+        };
+        this.functions = {};
+        if (this.signer &&
+            this.provider &&
+            this.abi &&
+            this.abi.methods &&
+            this.serializer) {
+            Object.keys(this.abi.methods).forEach((name) => {
+                this.functions[name] = async (argu = {}, options) => {
+                    if (!this.provider)
+                        throw new Error("provider not found");
+                    if (!this.abi || !this.abi.methods)
+                        throw new Error("Methods are not defined");
+                    if (!this.abi.methods[name])
+                        throw new Error(`Method ${name} not defined in the ABI`);
+                    const opts = {
+                        ...this.options,
+                        ...options,
+                    };
+                    const { readOnly, output, defaultOutput, preformatInput, preformatOutput, } = this.abi.methods[name];
+                    let args;
+                    if (typeof preformatInput === "function") {
+                        args = preformatInput(argu);
+                    }
+                    else {
+                        args = argu;
+                    }
+                    const operation = await this.encodeOperation({ name, args });
+                    if (readOnly) {
+                        if (!output)
+                            throw new Error(`No output defined for ${name}`);
+                        // read contract
+                        const { result: resultEncoded } = await this.provider.readContract({
+                            contract_id: utils_1.encodeBase58(operation.call_contract.contract_id),
+                            entry_point: operation.call_contract.entry_point,
+                            args: utils_1.encodeBase64(operation.call_contract.args),
+                        });
+                        let result = defaultOutput;
+                        if (resultEncoded) {
+                            result = await this.serializer.deserialize(resultEncoded, output);
+                        }
+                        if (typeof preformatOutput === "function") {
+                            result = preformatOutput(result);
+                        }
+                        return { operation, result };
+                    }
+                    // return operation if send is false
+                    if (!(opts === null || opts === void 0 ? void 0 : opts.sendTransaction))
+                        return { operation };
+                    // write contract (sign and send)
+                    if (!this.signer)
+                        throw new Error("signer not found");
+                    const transaction = await this.signer.encodeTransaction({
+                        ...opts,
+                        operations: [operation],
+                    });
+                    const abis = {};
+                    if (opts === null || opts === void 0 ? void 0 : opts.sendAbis) {
+                        const contractId = utils_1.encodeBase58(this.id);
+                        abis[contractId] = this.abi;
+                    }
+                    const transactionResponse = await this.signer.sendTransaction(transaction, abis);
+                    return { operation, transaction, transactionResponse };
+                };
+            });
+        }
+    }
+    /**
+     * Compute contract Id
+     */
+    static computeContractId(address) {
+        return utils_1.decodeBase58(address);
+    }
+    /**
+     * Get contract Id
+     */
+    getId() {
+        if (!this.id)
+            throw new Error("id is not defined");
+        return utils_1.encodeBase58(this.id);
+    }
+    /**
+     * Function to deploy a new smart contract.
+     * The Bytecode must be defined in the constructor of the class
+     * @example
+     * ```ts
+     * const privateKey = "f186a5de49797bfd52dc42505c33d75a46822ed5b60046e09d7c336242e20200";
+     * const provider = new Provider(["http://api.koinos.io:8080"]);
+     * const signer = new Signer({ privateKey, provider });
+     * const bytecode = new Uint8Array([1, 2, 3, 4]);
+     * const contract = new Contract({ signer, provider, bytecode });
+     * const { transactionResponse } = await contract.deploy();
+     * // wait to be mined
+     * const blockId = await transactionResponse.wait();
+     * console.log(`Contract uploaded in block id ${blockId}`);
+     * ```
+     */
+    async deploy(options) {
+        if (!this.signer)
+            throw new Error("signer not found");
+        if (!this.bytecode)
+            throw new Error("bytecode not found");
+        const opts = {
+            ...this.options,
+            ...options,
+        };
+        const operation = {
+            upload_contract: {
+                contract_id: Contract.computeContractId(this.signer.getAddress()),
+                bytecode: this.bytecode,
+            },
+        };
+        // return operation if send is false
+        if (!(opts === null || opts === void 0 ? void 0 : opts.sendTransaction))
+            return { operation };
+        const transaction = await this.signer.encodeTransaction({
+            ...opts,
+            operations: [operation],
+        });
+        const transactionResponse = await this.signer.sendTransaction(transaction);
+        return { operation, transaction, transactionResponse };
+    }
+    /**
+     * Encondes a contract operation using Koinos serialization
+     * and taking the contract entries as reference to build it
+     * @param op - Operation to encode
+     * @returns Operation encoded
+     * @example
+     * ```ts
+     * const opEncoded = contract.encodeOperation({
+     *   name: "transfer",
+     *   args: {
+     *     from: "12fN2CQnuJM8cMnWZ1hPtM4knjLME8E4PD",
+     *     to: "172AB1FgCsYrRAW5cwQ8KjadgxofvgPFd6",
+     *     value: "1000",
+     *   }
+     * });
+     *
+     * console.log(opEncoded);
+     * // {
+     * //   call_contract: {
+     * //     contract_id: "19JntSm8pSNETT9aHTwAUHC5RMoaSmgZPJ",
+     * //     entry_point: 0x62efa292,
+     * //     args: "MBWFsaWNlA2JvYgAAAAAAAAPo",
+     * //   }
+     * // }
+     * ```
+     */
+    async encodeOperation(op) {
+        if (!this.abi || !this.abi.methods || !this.abi.methods[op.name])
+            throw new Error(`Operation ${op.name} unknown`);
+        if (!this.serializer)
+            throw new Error("Serializer is not defined");
+        if (!this.id)
+            throw new Error("Contract id is not defined");
+        const method = this.abi.methods[op.name];
+        let bufferInputs = new Uint8Array(0);
+        if (method.input) {
+            if (!op.args)
+                throw new Error(`No arguments defined for type '${method.input}'`);
+            bufferInputs = await this.serializer.serialize(op.args, method.input);
+        }
+        return {
+            call_contract: {
+                contract_id: this.id,
+                entry_point: method.entryPoint,
+                args: bufferInputs,
+            },
+        };
+    }
+    /**
+     * Decodes a contract operation to be human readable
+     * @example
+     * ```ts
+     * const opDecoded = contract.decodeOperation({
+     *   call_contract: {
+     *     contract_id: "19JntSm8pSNETT9aHTwAUHC5RMoaSmgZPJ",
+     *     entry_point: 0x62efa292,
+     *     args: "MBWFsaWNlA2JvYgAAAAAAAAPo",
+     *   }
+     * });
+     * console.log(opDecoded);
+     * // {
+     * //   name: "transfer",
+     * //   args: {
+     * //     from: "12fN2CQnuJM8cMnWZ1hPtM4knjLME8E4PD",
+     * //     to: "172AB1FgCsYrRAW5cwQ8KjadgxofvgPFd6",
+     * //     value: "1000",
+     * //   },
+     * // }
+     * ```
+     */
+    async decodeOperation(op) {
+        if (!this.id)
+            throw new Error("Contract id is not defined");
+        if (!this.abi || !this.abi.methods)
+            throw new Error("Methods are not defined");
+        if (!this.serializer)
+            throw new Error("Serializer is not defined");
+        if (!op.call_contract)
+            throw new Error("Operation is not CallContractOperation");
+        if (utils_1.encodeBase58(op.call_contract.contract_id) !== utils_1.encodeBase58(this.id))
+            throw new Error(`Invalid contract id. Expected: ${utils_1.encodeBase58(this.id)}. Received: ${utils_1.encodeBase58(op.call_contract.contract_id)}`);
+        for (let i = 0; i < Object.keys(this.abi.methods).length; i += 1) {
+            const opName = Object.keys(this.abi.methods)[i];
+            const method = this.abi.methods[opName];
+            if (op.call_contract.entry_point === method.entryPoint) {
+                if (!method.input)
+                    return { name: opName };
+                return {
+                    name: opName,
+                    args: await this.serializer.deserialize(op.call_contract.args, method.input),
+                };
+            }
+        }
+        throw new Error(`Unknown method id ${op.call_contract.entry_point}`);
+    }
+}
+exports.Contract = Contract;
+exports.default = Contract;
 
 
 /***/ }),
@@ -11677,261 +11677,261 @@ exports.default = Contract;
 /***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
-
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.Provider = void 0;
-const axios_1 = __importDefault(__webpack_require__(9669));
-async function sleep(ms) {
-    return new Promise((r) => setTimeout(r, ms));
-}
-/**
- * Class to connect with the RPC node
- */
-class Provider {
-    /**
-     *
-     * @param rpcNodes - URL of the rpc node, or array of urls
-     * to switch between them when someone is down
-     * @example
-     * ```ts
-     * const provider = new Provider([
-     *   "http://45.56.104.152:8080",
-     *   "http://159.203.119.0:8080"
-     * ]);
-     * ```
-     */
-    constructor(rpcNodes) {
-        if (Array.isArray(rpcNodes))
-            this.rpcNodes = rpcNodes;
-        else
-            this.rpcNodes = [rpcNodes];
-        this.currentNodeId = 0;
-        this.onError = () => false;
-    }
-    /**
-     * Function to make jsonrpc requests to the RPC node
-     * @param method - jsonrpc method
-     * @param params - jsonrpc params
-     * @returns Result of jsonrpc response
-     */
-    async call(method, params) {
-        let response = {
-            data: {},
-            status: 0,
-            statusText: "",
-            headers: {},
-            config: {},
-        };
-        let success = false;
-        /* eslint-disable no-await-in-loop */
-        while (!success) {
-            try {
-                const data = {
-                    id: Math.round(Math.random() * 1000),
-                    jsonrpc: "2.0",
-                    method,
-                    params,
-                };
-                const url = this.rpcNodes[this.currentNodeId];
-                // TODO: search conditional to enable fetch for Browser
-                /* const response = await fetch(url, {
-                  method: "POST",
-                  body: JSON.stringify(data),
-                });
-                const json = await response.json();
-                if (json.error && json.error.message) throw new Error(json.error.message);
-                return json.result; */
-                response = await axios_1.default.post(url, data, { validateStatus: (s) => s < 400 });
-                success = true;
-            }
-            catch (e) {
-                const currentNode = this.rpcNodes[this.currentNodeId];
-                this.currentNodeId = (this.currentNodeId + 1) % this.rpcNodes.length;
-                const newNode = this.rpcNodes[this.currentNodeId];
-                const abort = this.onError(e, currentNode, newNode);
-                if (abort)
-                    throw e;
-            }
-        }
-        if (response.data.error)
-            throw new Error(JSON.stringify({
-                error: response.data.error,
-                request: { method, params },
-            }));
-        return response.data.result;
-    }
-    /**
-     * Function to call "chain.get_account_nonce" to return the number of
-     * transactions for a particular account. This call is used
-     * when creating new transactions.
-     * @param account - account address
-     * @returns Nonce
-     */
-    async getNonce(account) {
-        const { nonce } = await this.call("chain.get_account_nonce", { account });
-        if (!nonce)
-            return 0;
-        return Number(nonce);
-    }
-    async getAccountRc(account) {
-        const { rc } = await this.call("chain.get_account_rc", {
-            account,
-        });
-        if (!rc)
-            return "0";
-        return rc;
-    }
-    /**
-     * Get transactions by id and their corresponding block ids
-     */
-    async getTransactionsById(transactionIds) {
-        return this.call("transaction_store.get_transactions_by_id", {
-            transaction_ids: transactionIds,
-        });
-    }
-    async getBlocksById(blockIds) {
-        return this.call("block_store.get_blocks_by_id", {
-            block_id: blockIds,
-            return_block: true,
-            return_receipt: false,
-        });
-    }
-    /**
-     * Function to get info from the head block in the blockchain
-     */
-    async getHeadInfo() {
-        return this.call("chain.get_head_info", {});
-    }
-    /**
-     * Function to get consecutive blocks in descending order
-     * @param height - Starting block height
-     * @param numBlocks - Number of blocks to fetch
-     * @param idRef - Block ID reference to speed up searching blocks.
-     * This ID must be from a greater block height. By default it
-     * gets the ID from the block head.
-     */
-    async getBlocks(height, numBlocks = 1, idRef) {
-        let blockIdRef = idRef;
-        if (!blockIdRef) {
-            const head = await this.getHeadInfo();
-            blockIdRef = head.head_topology.id;
-        }
-        return (await this.call("block_store.get_blocks_by_height", {
-            head_block_id: blockIdRef,
-            ancestor_start_height: height,
-            num_blocks: numBlocks,
-            return_block: true,
-            return_receipt: false,
-        })).block_items;
-    }
-    /**
-     * Function to get a block by its height
-     */
-    async getBlock(height) {
-        return (await this.getBlocks(height, 1))[0];
-    }
-    /**
-     * Function to call "chain.submit_transaction" to send a signed
-     * transaction to the blockchain. It returns an object with the async
-     * function "wait", which can be called to wait for the
-     * transaction to be mined (see [[SendTransactionResponse]]).
-     * @param transaction - Signed transaction
-     * @example
-     * ```ts
-     * const { transactionResponse } = await provider.sendTransaction({
-     *   id: "1220...",
-     *   active: "...",
-     *   signatureData: "...",
-     * });
-     * console.log("Transaction submitted to the mempool");
-     * // wait to be mined
-     * const blockNumber = await transactionResponse.wait();
-     * // const blockNumber = await transactionResponse.wait("byBlock", 30000);
-     * // const blockId = await transactionResponse.wait("byTransactionId", 30000);
-     * console.log("Transaction mined")
-     * ```
-     */
-    async sendTransaction(transaction) {
-        await this.call("chain.submit_transaction", { transaction });
-        return {
-            wait: async (type = "byBlock", timeout = 30000) => {
-                const iniTime = Date.now();
-                if (type === "byTransactionId") {
-                    while (Date.now() < iniTime + timeout) {
-                        await sleep(1000);
-                        const { transactions } = await this.getTransactionsById([
-                            transaction.id,
-                        ]);
-                        if (transactions &&
-                            transactions[0] &&
-                            transactions[0].containing_blocks)
-                            return transactions[0].containing_blocks[0];
-                    }
-                    throw new Error(`Transaction not mined after ${timeout} ms`);
-                }
-                // byBlock
-                const findTxInBlocks = async (ini, numBlocks, idRef) => {
-                    const blocks = await this.getBlocks(ini, numBlocks, idRef);
-                    let bNum = 0;
-                    blocks.forEach((block) => {
-                        if (!block ||
-                            !block.block ||
-                            !block.block_id ||
-                            !block.block.transactions)
-                            return;
-                        const tx = block.block.transactions.find((t) => t.id === transaction.id);
-                        if (tx)
-                            bNum = Number(block.block_height);
-                    });
-                    let lastId = blocks[blocks.length - 1].block_id;
-                    return [bNum, lastId];
-                };
-                let blockNumber = 0;
-                let iniBlock = 0;
-                let previousId = "";
-                while (Date.now() < iniTime + timeout) {
-                    await sleep(1000);
-                    const { head_topology: headTopology } = await this.getHeadInfo();
-                    if (blockNumber === 0) {
-                        blockNumber = Number(headTopology.height);
-                        iniBlock = blockNumber;
-                    }
-                    if (Number(headTopology.height) === blockNumber - 1 &&
-                        previousId &&
-                        previousId !== headTopology.id) {
-                        const [bNum, lastId] = await findTxInBlocks(iniBlock, Number(headTopology.height) - iniBlock + 1, headTopology.id);
-                        if (bNum)
-                            return bNum;
-                        previousId = lastId;
-                        blockNumber = Number(headTopology.height) + 1;
-                    }
-                    if (blockNumber > Number(headTopology.height))
-                        continue;
-                    const [bNum, lastId] = await findTxInBlocks(blockNumber, 1, headTopology.id);
-                    if (bNum)
-                        return bNum;
-                    if (!previousId)
-                        previousId = lastId;
-                    blockNumber += 1;
-                }
-                throw new Error(`Transaction not mined after ${timeout} ms. Blocks checked from ${iniBlock} to ${blockNumber}`);
-            },
-        };
-    }
-    /**
-     * Function to call "chain.read_contract" to read a contract.
-     * This function is used by [[Contract]] class when read methods
-     * are invoked.
-     */
-    async readContract(operation) {
-        return this.call("chain.read_contract", operation);
-    }
-}
-exports.Provider = Provider;
-exports.default = Provider;
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.Provider = void 0;
+const axios_1 = __importDefault(__webpack_require__(9669));
+async function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+/**
+ * Class to connect with the RPC node
+ */
+class Provider {
+    /**
+     *
+     * @param rpcNodes - URL of the rpc node, or array of urls
+     * to switch between them when someone is down
+     * @example
+     * ```ts
+     * const provider = new Provider([
+     *   "http://45.56.104.152:8080",
+     *   "http://159.203.119.0:8080"
+     * ]);
+     * ```
+     */
+    constructor(rpcNodes) {
+        if (Array.isArray(rpcNodes))
+            this.rpcNodes = rpcNodes;
+        else
+            this.rpcNodes = [rpcNodes];
+        this.currentNodeId = 0;
+        this.onError = () => false;
+    }
+    /**
+     * Function to make jsonrpc requests to the RPC node
+     * @param method - jsonrpc method
+     * @param params - jsonrpc params
+     * @returns Result of jsonrpc response
+     */
+    async call(method, params) {
+        let response = {
+            data: {},
+            status: 0,
+            statusText: "",
+            headers: {},
+            config: {},
+        };
+        let success = false;
+        /* eslint-disable no-await-in-loop */
+        while (!success) {
+            try {
+                const data = {
+                    id: Math.round(Math.random() * 1000),
+                    jsonrpc: "2.0",
+                    method,
+                    params,
+                };
+                const url = this.rpcNodes[this.currentNodeId];
+                // TODO: search conditional to enable fetch for Browser
+                /* const response = await fetch(url, {
+                  method: "POST",
+                  body: JSON.stringify(data),
+                });
+                const json = await response.json();
+                if (json.error && json.error.message) throw new Error(json.error.message);
+                return json.result; */
+                response = await axios_1.default.post(url, data, { validateStatus: (s) => s < 400 });
+                success = true;
+            }
+            catch (e) {
+                const currentNode = this.rpcNodes[this.currentNodeId];
+                this.currentNodeId = (this.currentNodeId + 1) % this.rpcNodes.length;
+                const newNode = this.rpcNodes[this.currentNodeId];
+                const abort = this.onError(e, currentNode, newNode);
+                if (abort)
+                    throw e;
+            }
+        }
+        if (response.data.error)
+            throw new Error(JSON.stringify({
+                error: response.data.error,
+                request: { method, params },
+            }));
+        return response.data.result;
+    }
+    /**
+     * Function to call "chain.get_account_nonce" to return the number of
+     * transactions for a particular account. This call is used
+     * when creating new transactions.
+     * @param account - account address
+     * @returns Nonce
+     */
+    async getNonce(account) {
+        const { nonce } = await this.call("chain.get_account_nonce", { account });
+        if (!nonce)
+            return 0;
+        return Number(nonce);
+    }
+    async getAccountRc(account) {
+        const { rc } = await this.call("chain.get_account_rc", {
+            account,
+        });
+        if (!rc)
+            return "0";
+        return rc;
+    }
+    /**
+     * Get transactions by id and their corresponding block ids
+     */
+    async getTransactionsById(transactionIds) {
+        return this.call("transaction_store.get_transactions_by_id", {
+            transaction_ids: transactionIds,
+        });
+    }
+    async getBlocksById(blockIds) {
+        return this.call("block_store.get_blocks_by_id", {
+            block_id: blockIds,
+            return_block: true,
+            return_receipt: false,
+        });
+    }
+    /**
+     * Function to get info from the head block in the blockchain
+     */
+    async getHeadInfo() {
+        return this.call("chain.get_head_info", {});
+    }
+    /**
+     * Function to get consecutive blocks in descending order
+     * @param height - Starting block height
+     * @param numBlocks - Number of blocks to fetch
+     * @param idRef - Block ID reference to speed up searching blocks.
+     * This ID must be from a greater block height. By default it
+     * gets the ID from the block head.
+     */
+    async getBlocks(height, numBlocks = 1, idRef) {
+        let blockIdRef = idRef;
+        if (!blockIdRef) {
+            const head = await this.getHeadInfo();
+            blockIdRef = head.head_topology.id;
+        }
+        return (await this.call("block_store.get_blocks_by_height", {
+            head_block_id: blockIdRef,
+            ancestor_start_height: height,
+            num_blocks: numBlocks,
+            return_block: true,
+            return_receipt: false,
+        })).block_items;
+    }
+    /**
+     * Function to get a block by its height
+     */
+    async getBlock(height) {
+        return (await this.getBlocks(height, 1))[0];
+    }
+    /**
+     * Function to call "chain.submit_transaction" to send a signed
+     * transaction to the blockchain. It returns an object with the async
+     * function "wait", which can be called to wait for the
+     * transaction to be mined (see [[SendTransactionResponse]]).
+     * @param transaction - Signed transaction
+     * @example
+     * ```ts
+     * const { transactionResponse } = await provider.sendTransaction({
+     *   id: "1220...",
+     *   active: "...",
+     *   signatureData: "...",
+     * });
+     * console.log("Transaction submitted to the mempool");
+     * // wait to be mined
+     * const blockNumber = await transactionResponse.wait();
+     * // const blockNumber = await transactionResponse.wait("byBlock", 30000);
+     * // const blockId = await transactionResponse.wait("byTransactionId", 30000);
+     * console.log("Transaction mined")
+     * ```
+     */
+    async sendTransaction(transaction) {
+        await this.call("chain.submit_transaction", { transaction });
+        return {
+            wait: async (type = "byBlock", timeout = 30000) => {
+                const iniTime = Date.now();
+                if (type === "byTransactionId") {
+                    while (Date.now() < iniTime + timeout) {
+                        await sleep(1000);
+                        const { transactions } = await this.getTransactionsById([
+                            transaction.id,
+                        ]);
+                        if (transactions &&
+                            transactions[0] &&
+                            transactions[0].containing_blocks)
+                            return transactions[0].containing_blocks[0];
+                    }
+                    throw new Error(`Transaction not mined after ${timeout} ms`);
+                }
+                // byBlock
+                const findTxInBlocks = async (ini, numBlocks, idRef) => {
+                    const blocks = await this.getBlocks(ini, numBlocks, idRef);
+                    let bNum = 0;
+                    blocks.forEach((block) => {
+                        if (!block ||
+                            !block.block ||
+                            !block.block_id ||
+                            !block.block.transactions)
+                            return;
+                        const tx = block.block.transactions.find((t) => t.id === transaction.id);
+                        if (tx)
+                            bNum = Number(block.block_height);
+                    });
+                    let lastId = blocks[blocks.length - 1].block_id;
+                    return [bNum, lastId];
+                };
+                let blockNumber = 0;
+                let iniBlock = 0;
+                let previousId = "";
+                while (Date.now() < iniTime + timeout) {
+                    await sleep(1000);
+                    const { head_topology: headTopology } = await this.getHeadInfo();
+                    if (blockNumber === 0) {
+                        blockNumber = Number(headTopology.height);
+                        iniBlock = blockNumber;
+                    }
+                    if (Number(headTopology.height) === blockNumber - 1 &&
+                        previousId &&
+                        previousId !== headTopology.id) {
+                        const [bNum, lastId] = await findTxInBlocks(iniBlock, Number(headTopology.height) - iniBlock + 1, headTopology.id);
+                        if (bNum)
+                            return bNum;
+                        previousId = lastId;
+                        blockNumber = Number(headTopology.height) + 1;
+                    }
+                    if (blockNumber > Number(headTopology.height))
+                        continue;
+                    const [bNum, lastId] = await findTxInBlocks(blockNumber, 1, headTopology.id);
+                    if (bNum)
+                        return bNum;
+                    if (!previousId)
+                        previousId = lastId;
+                    blockNumber += 1;
+                }
+                throw new Error(`Transaction not mined after ${timeout} ms. Blocks checked from ${iniBlock} to ${blockNumber}`);
+            },
+        };
+    }
+    /**
+     * Function to call "chain.read_contract" to read a contract.
+     * This function is used by [[Contract]] class when read methods
+     * are invoked.
+     */
+    async readContract(operation) {
+        return this.call("chain.read_contract", operation);
+    }
+}
+exports.Provider = Provider;
+exports.default = Provider;
 
 
 /***/ }),
@@ -11940,174 +11940,174 @@ exports.default = Provider;
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.Serializer = void 0;
-/* eslint-disable @typescript-eslint/require-await */
-const light_1 = __webpack_require__(4492);
-const utils_1 = __webpack_require__(8593);
-const OP_BYTES = "(koinos_bytes_type)";
-/**
- * Makes a copy of a value. The returned value can be modified
- * without altering the original one. Although this is not needed
- * for strings or numbers and only needed for objects and arrays,
- * all these options are covered in a single function
- *
- * It is assumed that the argument is number, string, or contructions
- * of these types inside objects or arrays.
- */
-function copyValue(value) {
-    if (typeof value === "string" || typeof value === "number") {
-        return value;
-    }
-    return JSON.parse(JSON.stringify(value));
-}
-/**
- * The serializer class serialize and deserialize data using
- * protocol buffers.
- *
- * NOTE: This class uses the [protobufjs/light](https://www.npmjs.com/package/protobufjs)
- * library internally, which uses reflection (use of _eval_
- * and _new Function_) for the construction of the types.
- * This could cause issues in environments where _eval_ is not
- * allowed, like in browser extensions. In such cases, this class
- * must be confined in a [sandbox environment](https://developer.chrome.com/docs/apps/app_external/#sandboxing)
- * where _eval_ is allowed. This is the principal reason of
- * having the serializer in a separate class.
- *
- * @example
- *
- * ```ts
- * const descriptorJson = {
- *   nested: {
- *     awesomepackage: {
- *       nested: {
- *         AwesomeMessage: {
- *           fields: {
- *             awesomeField: {
- *               type: "string",
- *               id: 1
- *             }
- *           }
- *         }
- *       }
- *     }
- *   }
- * }
- * const serializer = new Serializer(descriptorJson)
- * ```
- */
-class Serializer {
-    constructor(types, opts) {
-        /**
-         * Preformat bytes for base64, base58 or hex string
-         */
-        this.bytesConversion = true;
-        this.types = types;
-        this.root = light_1.Root.fromJSON(this.types);
-        if (opts === null || opts === void 0 ? void 0 : opts.defaultTypeName)
-            this.defaultType = this.root.lookupType(opts.defaultTypeName);
-        if (opts && typeof opts.bytesConversion !== "undefined")
-            this.bytesConversion = opts.bytesConversion;
-    }
-    /**
-     * Function to encode a type using the protobuffer definitions
-     * It also prepares the bytes for special cases (base58, hex string)
-     * when bytesConversion param is true.
-     */
-    async serialize(valueDecoded, typeName) {
-        const protobufType = this.defaultType || this.root.lookupType(typeName);
-        let object = {};
-        if (this.bytesConversion) {
-            // TODO: format from Buffer to base58/base64 for nested fields
-            Object.keys(protobufType.fields).forEach((fieldName) => {
-                const { options, name, type } = protobufType.fields[fieldName];
-                // No byte conversion
-                if (type !== "bytes") {
-                    object[name] = copyValue(valueDecoded[name]);
-                    return;
-                }
-                // Default byte conversion
-                if (!options || !options[OP_BYTES]) {
-                    object[name] = utils_1.decodeBase64(valueDecoded[name]);
-                    return;
-                }
-                // Specific byte conversion
-                switch (options[OP_BYTES]) {
-                    case "BASE58":
-                    case "CONTRACT_ID":
-                    case "ADDRESS":
-                        object[name] = utils_1.decodeBase58(valueDecoded[name]);
-                        break;
-                    case "BASE64":
-                        object[name] = utils_1.decodeBase64(valueDecoded[name]);
-                        break;
-                    case "HEX":
-                    case "BLOCK_ID":
-                    case "TRANSACTION_ID":
-                        object[name] = utils_1.toUint8Array(valueDecoded[name].replace("0x", ""));
-                        break;
-                    default:
-                        throw new Error(`unknown koinos_byte_type ${options[OP_BYTES]}`);
-                }
-            });
-        }
-        else {
-            object = valueDecoded;
-        }
-        const message = protobufType.create(object);
-        const buffer = protobufType.encode(message).finish();
-        return buffer;
-    }
-    /**
-     * Function to decode bytes using the protobuffer definitions
-     * It also encodes the bytes for special cases (base58, hex string)
-     * when bytesConversion param is true.
-     */
-    async deserialize(valueEncoded, typeName) {
-        const valueBuffer = typeof valueEncoded === "string"
-            ? utils_1.decodeBase64(valueEncoded)
-            : valueEncoded;
-        const protobufType = this.defaultType || this.root.lookupType(typeName);
-        const message = protobufType.decode(valueBuffer);
-        const object = protobufType.toObject(message, { longs: String });
-        if (!this.bytesConversion)
-            return object;
-        // TODO: format from Buffer to base58/base64 for nested fields
-        Object.keys(protobufType.fields).forEach((fieldName) => {
-            const { options, name, type } = protobufType.fields[fieldName];
-            // No byte conversion
-            if (type !== "bytes")
-                return;
-            // Default byte conversion
-            if (!options || !options[OP_BYTES]) {
-                object[name] = utils_1.encodeBase64(object[name]);
-                return;
-            }
-            // Specific byte conversion
-            switch (options[OP_BYTES]) {
-                case "BASE58":
-                case "CONTRACT_ID":
-                case "ADDRESS":
-                    object[name] = utils_1.encodeBase58(object[name]);
-                    break;
-                case "BASE64":
-                    object[name] = utils_1.encodeBase64(object[name]);
-                    break;
-                case "HEX":
-                case "BLOCK_ID":
-                case "TRANSACTION_ID":
-                    object[name] = `0x${utils_1.toHexString(object[name])}`;
-                    break;
-                default:
-                    throw new Error(`unknown koinos_byte_type ${options[OP_BYTES]}`);
-            }
-        });
-        return object;
-    }
-}
-exports.Serializer = Serializer;
-exports.default = Serializer;
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.Serializer = void 0;
+/* eslint-disable @typescript-eslint/require-await */
+const light_1 = __webpack_require__(4492);
+const utils_1 = __webpack_require__(8593);
+const OP_BYTES = "(koinos_bytes_type)";
+/**
+ * Makes a copy of a value. The returned value can be modified
+ * without altering the original one. Although this is not needed
+ * for strings or numbers and only needed for objects and arrays,
+ * all these options are covered in a single function
+ *
+ * It is assumed that the argument is number, string, or contructions
+ * of these types inside objects or arrays.
+ */
+function copyValue(value) {
+    if (typeof value === "string" || typeof value === "number") {
+        return value;
+    }
+    return JSON.parse(JSON.stringify(value));
+}
+/**
+ * The serializer class serialize and deserialize data using
+ * protocol buffers.
+ *
+ * NOTE: This class uses the [protobufjs/light](https://www.npmjs.com/package/protobufjs)
+ * library internally, which uses reflection (use of _eval_
+ * and _new Function_) for the construction of the types.
+ * This could cause issues in environments where _eval_ is not
+ * allowed, like in browser extensions. In such cases, this class
+ * must be confined in a [sandbox environment](https://developer.chrome.com/docs/apps/app_external/#sandboxing)
+ * where _eval_ is allowed. This is the principal reason of
+ * having the serializer in a separate class.
+ *
+ * @example
+ *
+ * ```ts
+ * const descriptorJson = {
+ *   nested: {
+ *     awesomepackage: {
+ *       nested: {
+ *         AwesomeMessage: {
+ *           fields: {
+ *             awesomeField: {
+ *               type: "string",
+ *               id: 1
+ *             }
+ *           }
+ *         }
+ *       }
+ *     }
+ *   }
+ * }
+ * const serializer = new Serializer(descriptorJson)
+ * ```
+ */
+class Serializer {
+    constructor(types, opts) {
+        /**
+         * Preformat bytes for base64, base58 or hex string
+         */
+        this.bytesConversion = true;
+        this.types = types;
+        this.root = light_1.Root.fromJSON(this.types);
+        if (opts === null || opts === void 0 ? void 0 : opts.defaultTypeName)
+            this.defaultType = this.root.lookupType(opts.defaultTypeName);
+        if (opts && typeof opts.bytesConversion !== "undefined")
+            this.bytesConversion = opts.bytesConversion;
+    }
+    /**
+     * Function to encode a type using the protobuffer definitions
+     * It also prepares the bytes for special cases (base58, hex string)
+     * when bytesConversion param is true.
+     */
+    async serialize(valueDecoded, typeName) {
+        const protobufType = this.defaultType || this.root.lookupType(typeName);
+        let object = {};
+        if (this.bytesConversion) {
+            // TODO: format from Buffer to base58/base64 for nested fields
+            Object.keys(protobufType.fields).forEach((fieldName) => {
+                const { options, name, type } = protobufType.fields[fieldName];
+                // No byte conversion
+                if (type !== "bytes") {
+                    object[name] = copyValue(valueDecoded[name]);
+                    return;
+                }
+                // Default byte conversion
+                if (!options || !options[OP_BYTES]) {
+                    object[name] = utils_1.decodeBase64(valueDecoded[name]);
+                    return;
+                }
+                // Specific byte conversion
+                switch (options[OP_BYTES]) {
+                    case "BASE58":
+                    case "CONTRACT_ID":
+                    case "ADDRESS":
+                        object[name] = utils_1.decodeBase58(valueDecoded[name]);
+                        break;
+                    case "BASE64":
+                        object[name] = utils_1.decodeBase64(valueDecoded[name]);
+                        break;
+                    case "HEX":
+                    case "BLOCK_ID":
+                    case "TRANSACTION_ID":
+                        object[name] = utils_1.toUint8Array(valueDecoded[name].replace("0x", ""));
+                        break;
+                    default:
+                        throw new Error(`unknown koinos_byte_type ${options[OP_BYTES]}`);
+                }
+            });
+        }
+        else {
+            object = valueDecoded;
+        }
+        const message = protobufType.create(object);
+        const buffer = protobufType.encode(message).finish();
+        return buffer;
+    }
+    /**
+     * Function to decode bytes using the protobuffer definitions
+     * It also encodes the bytes for special cases (base58, hex string)
+     * when bytesConversion param is true.
+     */
+    async deserialize(valueEncoded, typeName) {
+        const valueBuffer = typeof valueEncoded === "string"
+            ? utils_1.decodeBase64(valueEncoded)
+            : valueEncoded;
+        const protobufType = this.defaultType || this.root.lookupType(typeName);
+        const message = protobufType.decode(valueBuffer);
+        const object = protobufType.toObject(message, { longs: String });
+        if (!this.bytesConversion)
+            return object;
+        // TODO: format from Buffer to base58/base64 for nested fields
+        Object.keys(protobufType.fields).forEach((fieldName) => {
+            const { options, name, type } = protobufType.fields[fieldName];
+            // No byte conversion
+            if (type !== "bytes")
+                return;
+            // Default byte conversion
+            if (!options || !options[OP_BYTES]) {
+                object[name] = utils_1.encodeBase64(object[name]);
+                return;
+            }
+            // Specific byte conversion
+            switch (options[OP_BYTES]) {
+                case "BASE58":
+                case "CONTRACT_ID":
+                case "ADDRESS":
+                    object[name] = utils_1.encodeBase58(object[name]);
+                    break;
+                case "BASE64":
+                    object[name] = utils_1.encodeBase64(object[name]);
+                    break;
+                case "HEX":
+                case "BLOCK_ID":
+                case "TRANSACTION_ID":
+                    object[name] = `0x${utils_1.toHexString(object[name])}`;
+                    break;
+                default:
+                    throw new Error(`unknown koinos_byte_type ${options[OP_BYTES]}`);
+            }
+        });
+        return object;
+    }
+}
+exports.Serializer = Serializer;
+exports.default = Serializer;
 
 
 /***/ }),
@@ -12116,426 +12116,426 @@ exports.default = Serializer;
 /***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
-
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.Signer = void 0;
-/* eslint-disable no-param-reassign */
-const sha256_1 = __webpack_require__(5374);
-const secp = __importStar(__webpack_require__(1337));
-const protocol_proto_json_1 = __importDefault(__webpack_require__(6139));
-const utils_1 = __webpack_require__(8593);
-const Serializer_1 = __webpack_require__(7187);
-/**
- * The Signer Class contains the private key needed to sign transactions.
- * It can be created using the seed, wif, or private key
- *
- * @example
- * using private key as hex string
- * ```ts
- * var privateKey = "ec8601a24f81decd57f4b611b5ac6eb801cb3780bb02c0f9cdfe9d09daaddf9c";
- * var signer = new Signer({ privateKey });
- * ```
- * <br>
- *
- * using private key as Uint8Array
- * ```ts
- * var buffer = new Uint8Array([
- *   236, 134,   1, 162,  79, 129, 222, 205,
- *    87, 244, 182,  17, 181, 172, 110, 184,
- *     1, 203,  55, 128, 187,   2, 192, 249,
- *   205, 254, 157,   9, 218, 173, 223, 156
- * ]);
- * var signer = new Signer({ privateKey: buffer });
- * ```
- *
- * <br>
- *
- * using private key as bigint
- * ```ts
- * var privateKey = 106982601049961974618234078204952280507266494766432547312316920283818886029212n;
- * var signer = new Signer({ privateKey });
- * ```
- *
- * <br>
- *
- * using the seed
- * ```ts
- * var signer = Signer.fromSeed("my seed");
- * ```
- *
- * <br>
- *
- * using private key in WIF format
- * ```ts
- * var signer = Signer.fromWif("L59UtJcTdNBnrH2QSBA5beSUhRufRu3g6tScDTite6Msuj7U93tM");
- * ```
- *
- * <br>
- *
- * defining a provider
- * ```ts
- * var provider = new Provider(["https://example.com/jsonrpc"]);
- * var privateKey = "ec8601a24f81decd57f4b611b5ac6eb801cb3780bb02c0f9cdfe9d09daaddf9c";
- * var signer = new Signer({ privateKey, provider });
- * ```
- */
-class Signer {
-    /**
-     * The constructor receives de private key as hexstring, bigint or Uint8Array.
-     * See also the functions [[Signer.fromWif]] and [[Signer.fromSeed]]
-     * to create the signer from the WIF or Seed respectively.
-     *
-     * @param privateKey - Private key as hexstring, bigint or Uint8Array
-     * @param compressed - compressed format is true by default
-     * @param provider - provider to connect with the blockchain
-     * @example
-     * ```ts
-     * const privateKey = "ec8601a24f81decd57f4b611b5ac6eb801cb3780bb02c0f9cdfe9d09daaddf9c";
-     * cons signer = new Signer({ privateKey });
-     * console.log(signer.getAddress());
-     * // 1MbL6mG8ASAvSYdoMnGUfG3ZXkmQ2dpL5b
-     * ```
-     */
-    constructor(c) {
-        this.compressed = typeof c.compressed === "undefined" ? true : c.compressed;
-        this.privateKey = c.privateKey;
-        this.provider = c.provider;
-        if (c.serializer) {
-            this.serializer = c.serializer;
-        }
-        else {
-            this.serializer = new Serializer_1.Serializer(protocol_proto_json_1.default, {
-                defaultTypeName: "active_transaction_data",
-                bytesConversion: false,
-            });
-        }
-        if (typeof c.privateKey === "string") {
-            this.publicKey = secp.getPublicKey(c.privateKey, this.compressed);
-            this.address = utils_1.bitcoinAddress(utils_1.toUint8Array(this.publicKey));
-        }
-        else {
-            this.publicKey = secp.getPublicKey(c.privateKey, this.compressed);
-            this.address = utils_1.bitcoinAddress(this.publicKey);
-        }
-    }
-    /**
-     * Function to import a private key from the WIF
-     * @param wif  - Private key in WIF format
-     * @example
-     * ```ts
-     * const signer = Signer.fromWif("L59UtJcTdNBnrH2QSBA5beSUhRufRu3g6tScDTite6Msuj7U93tM")
-     * console.log(signer.getAddress());
-     * // 1MbL6mG8ASAvSYdoMnGUfG3ZXkmQ2dpL5b
-     * ```
-     * @returns Signer object
-     */
-    static fromWif(wif) {
-        const compressed = wif[0] !== "5";
-        const privateKey = utils_1.bitcoinDecode(wif);
-        return new Signer({
-            privateKey: utils_1.toHexString(privateKey),
-            compressed,
-        });
-    }
-    /**
-     * Function to import a private key from the seed
-     * @param seed - Seed words
-     * @param compressed -
-     * @example
-     * ```ts
-     * const signer = Signer.fromSeed("my seed");
-     * console.log(signer.getAddress());
-     * // 1BqtgWBcqm9cSZ97avLGZGJdgso7wx6pCA
-     * ```
-     * @returns Signer object
-     */
-    static fromSeed(seed, compressed) {
-        const privateKey = sha256_1.sha256(seed);
-        return new Signer({ privateKey, compressed });
-    }
-    /**
-     * @param compressed - determines if the address should be
-     * derived from the compressed public key (default) or the public key
-     * @returns Signer address
-     */
-    getAddress(compressed = true) {
-        if (typeof this.privateKey === "string") {
-            const publicKey = secp.getPublicKey(this.privateKey, compressed);
-            return utils_1.bitcoinAddress(utils_1.toUint8Array(publicKey));
-        }
-        const publicKey = secp.getPublicKey(this.privateKey, compressed);
-        return utils_1.bitcoinAddress(publicKey);
-    }
-    /**
-     * Function to get the private key in hex format or wif format
-     * @param format - The format must be "hex" (default) or "wif"
-     * @param compressed - Optional arg when using WIF format. By default it
-     * uses the compressed value defined in the signer
-     * @example
-     * ```ts
-     * const signer = Signer.fromSeed("one two three four five six");
-     * console.log(signer.getPrivateKey());
-     * // bab7fd6e5bd624f4ea0c33f7e7219262a6fa93a945a8964d9f110148286b7b37
-     *
-     * console.log(signer.getPrivateKey("wif"));
-     * // L3UfgFJWmbVziGB1uZBjkG1UjKkF7hhpXWY7mbTUdmycmvXCVtiL
-     *
-     * console.log(signer.getPrivateKey("wif", false));
-     * // 5KEX4TMHG66fT7cM9HMZLmdp4hVq4LC4X2Fkg6zeypM5UteWmtd
-     * ```
-     */
-    getPrivateKey(format = "hex", compressed) {
-        let stringPrivateKey;
-        if (this.privateKey instanceof Uint8Array) {
-            stringPrivateKey = utils_1.toHexString(this.privateKey);
-        }
-        else if (typeof this.privateKey === "string") {
-            stringPrivateKey = this.privateKey;
-        }
-        else {
-            stringPrivateKey = BigInt(this.privateKey).toString(16).padStart(64, "0");
-        }
-        const comp = compressed === undefined ? this.compressed : compressed;
-        switch (format) {
-            case "hex":
-                return stringPrivateKey;
-            case "wif":
-                return utils_1.bitcoinEncode(utils_1.toUint8Array(stringPrivateKey), "private", comp);
-            default:
-                /* eslint-disable-next-line @typescript-eslint/restrict-template-expressions */
-                throw new Error(`Invalid format ${format}`);
-        }
-    }
-    /**
-     * Function to sign a transaction. It's important to remark that
-     * the transaction parameter is modified inside this function.
-     * @param tx - Unsigned transaction
-     * @returns
-     */
-    async signTransaction(tx) {
-        if (!tx.active)
-            throw new Error("Active data is not defined");
-        const hash = sha256_1.sha256(utils_1.decodeBase64(tx.active));
-        const [compSignature, recovery] = await secp.sign(hash, this.privateKey, {
-            recovered: true,
-            canonical: true,
-            der: false, // compact signature
-        });
-        const compactSignature = new Uint8Array(65);
-        compactSignature.set([recovery + 31], 0);
-        compactSignature.set(compSignature, 1);
-        tx.signature_data = utils_1.encodeBase64(compactSignature);
-        const multihash = `0x1220${utils_1.toHexString(hash)}`; // 12: code sha2-256. 20: length (32 bytes)
-        tx.id = multihash;
-        return tx;
-    }
-    /**
-     * Function to sign and send a transaction. It internally uses
-     * [[Provider.sendTransaction]]
-     * @param tx - Transaction to send. It will be signed inside this function
-     * if it is not signed yet
-     * @param _abis - Collection of Abis to parse the operations in the
-     * transaction. This parameter is optional.
-     * @returns
-     */
-    async sendTransaction(tx, _abis) {
-        if (!tx.signature_data || !tx.id)
-            await this.signTransaction(tx);
-        if (!this.provider)
-            throw new Error("provider is undefined");
-        return this.provider.sendTransaction(tx);
-    }
-    /**
-     * Function to recover the public key from a signed
-     * transaction or block.
-     * The output format can be compressed (default) or uncompressed.
-     *
-     * @example
-     * ```ts
-     * const publicKey = await Signer.recoverPublicKey(tx);
-     * ```
-     *
-     * If the signature data contains more data, like in the
-     * blocks for PoW consensus, use the "transformSignature"
-     * function to extract the signature.
-     *
-     * @example
-     * ```ts
-     *  const powDescriptorJson = {
-     *    nested: {
-     *      mypackage: {
-     *        nested: {
-     *          pow_signature_data: {
-     *            fields: {
-     *              nonce: {
-     *                type: "bytes",
-     *                id: 1,
-     *              },
-     *              recoverable_signature: {
-     *                type: "bytes",
-     *                id: 2,
-     *              },
-     *            },
-     *          },
-     *        },
-     *      },
-     *    },
-     *  };
-     *
-     *  const serializer = new Serializer(powDescriptorJson, {
-     *   defaultTypeName: "pow_signature_data",
-     *  });
-     *
-     *  const signer = await Signer.recoverPublicKey(block, {
-     *    transformSignature: async (signatureData) => {
-     *      const powSignatureData = await serializer.deserialize(signatureData);
-     *      return powSignatureData.recoverable_signature;
-     *    },
-     *  });
-     * ```
-     */
-    static async recoverPublicKey(txOrBlock, opts) {
-        if (!txOrBlock.active)
-            throw new Error("active is not defined");
-        if (!txOrBlock.signature_data)
-            throw new Error("signature_data is not defined");
-        let signatureData = txOrBlock.signature_data;
-        if (opts && typeof opts.transformSignature === "function") {
-            signatureData = await opts.transformSignature(txOrBlock.signature_data);
-        }
-        let compressed = true;
-        if (opts && typeof opts.compressed !== "undefined") {
-            compressed = opts.compressed;
-        }
-        const hash = sha256_1.sha256(utils_1.decodeBase64(txOrBlock.active));
-        const compactSignatureHex = utils_1.toHexString(utils_1.decodeBase64(signatureData));
-        const recovery = Number(`0x${compactSignatureHex.slice(0, 2)}`) - 31;
-        const rHex = compactSignatureHex.slice(2, 66);
-        const sHex = compactSignatureHex.slice(66);
-        const r = BigInt(`0x${rHex}`);
-        const s = BigInt(`0x${sHex}`);
-        const sig = new secp.Signature(r, s);
-        const publicKey = secp.recoverPublicKey(utils_1.toHexString(hash), sig.toHex(), recovery);
-        if (!publicKey)
-            throw new Error("Public key cannot be recovered");
-        if (!compressed)
-            return publicKey;
-        return secp.Point.fromHex(publicKey).toHex(true);
-    }
-    /**
-     * Function to recover the signer address from a signed
-     * transaction or block.
-     * The output format can be compressed (default) or uncompressed.
-     * @example
-     * ```ts
-     * const publicKey = await Signer.recoverAddress(tx);
-     * ```
-     *
-     * If the signature data contains more data, like in the
-     * blocks for PoW consensus, use the "transformSignature"
-     * function to extract the signature.
-     *
-     * @example
-     * ```ts
-     *  const powDescriptorJson = {
-     *    nested: {
-     *      mypackage: {
-     *        nested: {
-     *          pow_signature_data: {
-     *            fields: {
-     *              nonce: {
-     *                type: "bytes",
-     *                id: 1,
-     *              },
-     *              recoverable_signature: {
-     *                type: "bytes",
-     *                id: 2,
-     *              },
-     *            },
-     *          },
-     *        },
-     *      },
-     *    },
-     *  };
-     *
-     *  const serializer = new Serializer(powDescriptorJson, {
-     *   defaultTypeName: "pow_signature_data",
-     *  });
-     *
-     *  const signer = await Signer.recoverAddress(block, {
-     *    transformSignature: async (signatureData) => {
-     *      const powSignatureData = await serializer.deserialize(signatureData);
-     *      return powSignatureData.recoverable_signature;
-     *    },
-     *  });
-     * ```
-     */
-    static async recoverAddress(txOrBlock, opts) {
-        const publicKey = await Signer.recoverPublicKey(txOrBlock, opts);
-        return utils_1.bitcoinAddress(utils_1.toUint8Array(publicKey));
-    }
-    /**
-     * Function to encode a transaction
-     * @param activeData - Active data consists of nonce, rc_limit, and
-     * operations. Do not set the nonce to get it from the blockchain
-     * using the provider. The rc_limit is 1000000 by default.
-     * @returns A transaction encoded. The active field is encoded in
-     * base64url
-     */
-    async encodeTransaction(activeData) {
-        let { nonce } = activeData;
-        if (activeData.nonce === undefined) {
-            if (!this.provider)
-                throw new Error("Cannot get the nonce because provider is undefined. To skip this call set a nonce in the parameters");
-            // TODO: Option to resolve names
-            // this depends on the final architecture for names on Koinos
-            nonce = await this.provider.getNonce(this.getAddress());
-        }
-        const rcLimit = activeData.rc_limit === undefined ? 1000000 : activeData.rc_limit;
-        const operations = activeData.operations ? activeData.operations : [];
-        const activeData2 = {
-            rc_limit: rcLimit,
-            nonce,
-            operations,
-        };
-        const buffer = await this.serializer.serialize(activeData2);
-        return {
-            active: utils_1.encodeBase64(buffer),
-        };
-    }
-    /**
-     * Function to decode a transaction
-     */
-    async decodeTransaction(tx) {
-        if (!tx.active)
-            throw new Error("Active data is not defined");
-        return this.serializer.deserialize(tx.active);
-    }
-}
-exports.Signer = Signer;
-exports.default = Signer;
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.Signer = void 0;
+/* eslint-disable no-param-reassign */
+const sha256_1 = __webpack_require__(5374);
+const secp = __importStar(__webpack_require__(1337));
+const protocol_proto_json_1 = __importDefault(__webpack_require__(6139));
+const utils_1 = __webpack_require__(8593);
+const Serializer_1 = __webpack_require__(7187);
+/**
+ * The Signer Class contains the private key needed to sign transactions.
+ * It can be created using the seed, wif, or private key
+ *
+ * @example
+ * using private key as hex string
+ * ```ts
+ * var privateKey = "ec8601a24f81decd57f4b611b5ac6eb801cb3780bb02c0f9cdfe9d09daaddf9c";
+ * var signer = new Signer({ privateKey });
+ * ```
+ * <br>
+ *
+ * using private key as Uint8Array
+ * ```ts
+ * var buffer = new Uint8Array([
+ *   236, 134,   1, 162,  79, 129, 222, 205,
+ *    87, 244, 182,  17, 181, 172, 110, 184,
+ *     1, 203,  55, 128, 187,   2, 192, 249,
+ *   205, 254, 157,   9, 218, 173, 223, 156
+ * ]);
+ * var signer = new Signer({ privateKey: buffer });
+ * ```
+ *
+ * <br>
+ *
+ * using private key as bigint
+ * ```ts
+ * var privateKey = 106982601049961974618234078204952280507266494766432547312316920283818886029212n;
+ * var signer = new Signer({ privateKey });
+ * ```
+ *
+ * <br>
+ *
+ * using the seed
+ * ```ts
+ * var signer = Signer.fromSeed("my seed");
+ * ```
+ *
+ * <br>
+ *
+ * using private key in WIF format
+ * ```ts
+ * var signer = Signer.fromWif("L59UtJcTdNBnrH2QSBA5beSUhRufRu3g6tScDTite6Msuj7U93tM");
+ * ```
+ *
+ * <br>
+ *
+ * defining a provider
+ * ```ts
+ * var provider = new Provider(["https://example.com/jsonrpc"]);
+ * var privateKey = "ec8601a24f81decd57f4b611b5ac6eb801cb3780bb02c0f9cdfe9d09daaddf9c";
+ * var signer = new Signer({ privateKey, provider });
+ * ```
+ */
+class Signer {
+    /**
+     * The constructor receives de private key as hexstring, bigint or Uint8Array.
+     * See also the functions [[Signer.fromWif]] and [[Signer.fromSeed]]
+     * to create the signer from the WIF or Seed respectively.
+     *
+     * @param privateKey - Private key as hexstring, bigint or Uint8Array
+     * @param compressed - compressed format is true by default
+     * @param provider - provider to connect with the blockchain
+     * @example
+     * ```ts
+     * const privateKey = "ec8601a24f81decd57f4b611b5ac6eb801cb3780bb02c0f9cdfe9d09daaddf9c";
+     * cons signer = new Signer({ privateKey });
+     * console.log(signer.getAddress());
+     * // 1MbL6mG8ASAvSYdoMnGUfG3ZXkmQ2dpL5b
+     * ```
+     */
+    constructor(c) {
+        this.compressed = typeof c.compressed === "undefined" ? true : c.compressed;
+        this.privateKey = c.privateKey;
+        this.provider = c.provider;
+        if (c.serializer) {
+            this.serializer = c.serializer;
+        }
+        else {
+            this.serializer = new Serializer_1.Serializer(protocol_proto_json_1.default, {
+                defaultTypeName: "active_transaction_data",
+                bytesConversion: false,
+            });
+        }
+        if (typeof c.privateKey === "string") {
+            this.publicKey = secp.getPublicKey(c.privateKey, this.compressed);
+            this.address = utils_1.bitcoinAddress(utils_1.toUint8Array(this.publicKey));
+        }
+        else {
+            this.publicKey = secp.getPublicKey(c.privateKey, this.compressed);
+            this.address = utils_1.bitcoinAddress(this.publicKey);
+        }
+    }
+    /**
+     * Function to import a private key from the WIF
+     * @param wif  - Private key in WIF format
+     * @example
+     * ```ts
+     * const signer = Signer.fromWif("L59UtJcTdNBnrH2QSBA5beSUhRufRu3g6tScDTite6Msuj7U93tM")
+     * console.log(signer.getAddress());
+     * // 1MbL6mG8ASAvSYdoMnGUfG3ZXkmQ2dpL5b
+     * ```
+     * @returns Signer object
+     */
+    static fromWif(wif) {
+        const compressed = wif[0] !== "5";
+        const privateKey = utils_1.bitcoinDecode(wif);
+        return new Signer({
+            privateKey: utils_1.toHexString(privateKey),
+            compressed,
+        });
+    }
+    /**
+     * Function to import a private key from the seed
+     * @param seed - Seed words
+     * @param compressed -
+     * @example
+     * ```ts
+     * const signer = Signer.fromSeed("my seed");
+     * console.log(signer.getAddress());
+     * // 1BqtgWBcqm9cSZ97avLGZGJdgso7wx6pCA
+     * ```
+     * @returns Signer object
+     */
+    static fromSeed(seed, compressed) {
+        const privateKey = sha256_1.sha256(seed);
+        return new Signer({ privateKey, compressed });
+    }
+    /**
+     * @param compressed - determines if the address should be
+     * derived from the compressed public key (default) or the public key
+     * @returns Signer address
+     */
+    getAddress(compressed = true) {
+        if (typeof this.privateKey === "string") {
+            const publicKey = secp.getPublicKey(this.privateKey, compressed);
+            return utils_1.bitcoinAddress(utils_1.toUint8Array(publicKey));
+        }
+        const publicKey = secp.getPublicKey(this.privateKey, compressed);
+        return utils_1.bitcoinAddress(publicKey);
+    }
+    /**
+     * Function to get the private key in hex format or wif format
+     * @param format - The format must be "hex" (default) or "wif"
+     * @param compressed - Optional arg when using WIF format. By default it
+     * uses the compressed value defined in the signer
+     * @example
+     * ```ts
+     * const signer = Signer.fromSeed("one two three four five six");
+     * console.log(signer.getPrivateKey());
+     * // bab7fd6e5bd624f4ea0c33f7e7219262a6fa93a945a8964d9f110148286b7b37
+     *
+     * console.log(signer.getPrivateKey("wif"));
+     * // L3UfgFJWmbVziGB1uZBjkG1UjKkF7hhpXWY7mbTUdmycmvXCVtiL
+     *
+     * console.log(signer.getPrivateKey("wif", false));
+     * // 5KEX4TMHG66fT7cM9HMZLmdp4hVq4LC4X2Fkg6zeypM5UteWmtd
+     * ```
+     */
+    getPrivateKey(format = "hex", compressed) {
+        let stringPrivateKey;
+        if (this.privateKey instanceof Uint8Array) {
+            stringPrivateKey = utils_1.toHexString(this.privateKey);
+        }
+        else if (typeof this.privateKey === "string") {
+            stringPrivateKey = this.privateKey;
+        }
+        else {
+            stringPrivateKey = BigInt(this.privateKey).toString(16).padStart(64, "0");
+        }
+        const comp = compressed === undefined ? this.compressed : compressed;
+        switch (format) {
+            case "hex":
+                return stringPrivateKey;
+            case "wif":
+                return utils_1.bitcoinEncode(utils_1.toUint8Array(stringPrivateKey), "private", comp);
+            default:
+                /* eslint-disable-next-line @typescript-eslint/restrict-template-expressions */
+                throw new Error(`Invalid format ${format}`);
+        }
+    }
+    /**
+     * Function to sign a transaction. It's important to remark that
+     * the transaction parameter is modified inside this function.
+     * @param tx - Unsigned transaction
+     * @returns
+     */
+    async signTransaction(tx) {
+        if (!tx.active)
+            throw new Error("Active data is not defined");
+        const hash = sha256_1.sha256(utils_1.decodeBase64(tx.active));
+        const [compSignature, recovery] = await secp.sign(hash, this.privateKey, {
+            recovered: true,
+            canonical: true,
+            der: false, // compact signature
+        });
+        const compactSignature = new Uint8Array(65);
+        compactSignature.set([recovery + 31], 0);
+        compactSignature.set(compSignature, 1);
+        tx.signature_data = utils_1.encodeBase64(compactSignature);
+        const multihash = `0x1220${utils_1.toHexString(hash)}`; // 12: code sha2-256. 20: length (32 bytes)
+        tx.id = multihash;
+        return tx;
+    }
+    /**
+     * Function to sign and send a transaction. It internally uses
+     * [[Provider.sendTransaction]]
+     * @param tx - Transaction to send. It will be signed inside this function
+     * if it is not signed yet
+     * @param _abis - Collection of Abis to parse the operations in the
+     * transaction. This parameter is optional.
+     * @returns
+     */
+    async sendTransaction(tx, _abis) {
+        if (!tx.signature_data || !tx.id)
+            await this.signTransaction(tx);
+        if (!this.provider)
+            throw new Error("provider is undefined");
+        return this.provider.sendTransaction(tx);
+    }
+    /**
+     * Function to recover the public key from a signed
+     * transaction or block.
+     * The output format can be compressed (default) or uncompressed.
+     *
+     * @example
+     * ```ts
+     * const publicKey = await Signer.recoverPublicKey(tx);
+     * ```
+     *
+     * If the signature data contains more data, like in the
+     * blocks for PoW consensus, use the "transformSignature"
+     * function to extract the signature.
+     *
+     * @example
+     * ```ts
+     *  const powDescriptorJson = {
+     *    nested: {
+     *      mypackage: {
+     *        nested: {
+     *          pow_signature_data: {
+     *            fields: {
+     *              nonce: {
+     *                type: "bytes",
+     *                id: 1,
+     *              },
+     *              recoverable_signature: {
+     *                type: "bytes",
+     *                id: 2,
+     *              },
+     *            },
+     *          },
+     *        },
+     *      },
+     *    },
+     *  };
+     *
+     *  const serializer = new Serializer(powDescriptorJson, {
+     *   defaultTypeName: "pow_signature_data",
+     *  });
+     *
+     *  const signer = await Signer.recoverPublicKey(block, {
+     *    transformSignature: async (signatureData) => {
+     *      const powSignatureData = await serializer.deserialize(signatureData);
+     *      return powSignatureData.recoverable_signature;
+     *    },
+     *  });
+     * ```
+     */
+    static async recoverPublicKey(txOrBlock, opts) {
+        if (!txOrBlock.active)
+            throw new Error("active is not defined");
+        if (!txOrBlock.signature_data)
+            throw new Error("signature_data is not defined");
+        let signatureData = txOrBlock.signature_data;
+        if (opts && typeof opts.transformSignature === "function") {
+            signatureData = await opts.transformSignature(txOrBlock.signature_data);
+        }
+        let compressed = true;
+        if (opts && typeof opts.compressed !== "undefined") {
+            compressed = opts.compressed;
+        }
+        const hash = sha256_1.sha256(utils_1.decodeBase64(txOrBlock.active));
+        const compactSignatureHex = utils_1.toHexString(utils_1.decodeBase64(signatureData));
+        const recovery = Number(`0x${compactSignatureHex.slice(0, 2)}`) - 31;
+        const rHex = compactSignatureHex.slice(2, 66);
+        const sHex = compactSignatureHex.slice(66);
+        const r = BigInt(`0x${rHex}`);
+        const s = BigInt(`0x${sHex}`);
+        const sig = new secp.Signature(r, s);
+        const publicKey = secp.recoverPublicKey(utils_1.toHexString(hash), sig.toHex(), recovery);
+        if (!publicKey)
+            throw new Error("Public key cannot be recovered");
+        if (!compressed)
+            return publicKey;
+        return secp.Point.fromHex(publicKey).toHex(true);
+    }
+    /**
+     * Function to recover the signer address from a signed
+     * transaction or block.
+     * The output format can be compressed (default) or uncompressed.
+     * @example
+     * ```ts
+     * const publicKey = await Signer.recoverAddress(tx);
+     * ```
+     *
+     * If the signature data contains more data, like in the
+     * blocks for PoW consensus, use the "transformSignature"
+     * function to extract the signature.
+     *
+     * @example
+     * ```ts
+     *  const powDescriptorJson = {
+     *    nested: {
+     *      mypackage: {
+     *        nested: {
+     *          pow_signature_data: {
+     *            fields: {
+     *              nonce: {
+     *                type: "bytes",
+     *                id: 1,
+     *              },
+     *              recoverable_signature: {
+     *                type: "bytes",
+     *                id: 2,
+     *              },
+     *            },
+     *          },
+     *        },
+     *      },
+     *    },
+     *  };
+     *
+     *  const serializer = new Serializer(powDescriptorJson, {
+     *   defaultTypeName: "pow_signature_data",
+     *  });
+     *
+     *  const signer = await Signer.recoverAddress(block, {
+     *    transformSignature: async (signatureData) => {
+     *      const powSignatureData = await serializer.deserialize(signatureData);
+     *      return powSignatureData.recoverable_signature;
+     *    },
+     *  });
+     * ```
+     */
+    static async recoverAddress(txOrBlock, opts) {
+        const publicKey = await Signer.recoverPublicKey(txOrBlock, opts);
+        return utils_1.bitcoinAddress(utils_1.toUint8Array(publicKey));
+    }
+    /**
+     * Function to encode a transaction
+     * @param activeData - Active data consists of nonce, rc_limit, and
+     * operations. Do not set the nonce to get it from the blockchain
+     * using the provider. The rc_limit is 1000000 by default.
+     * @returns A transaction encoded. The active field is encoded in
+     * base64url
+     */
+    async encodeTransaction(activeData) {
+        let { nonce } = activeData;
+        if (activeData.nonce === undefined) {
+            if (!this.provider)
+                throw new Error("Cannot get the nonce because provider is undefined. To skip this call set a nonce in the parameters");
+            // TODO: Option to resolve names
+            // this depends on the final architecture for names on Koinos
+            nonce = await this.provider.getNonce(this.getAddress());
+        }
+        const rcLimit = activeData.rc_limit === undefined ? 1000000 : activeData.rc_limit;
+        const operations = activeData.operations ? activeData.operations : [];
+        const activeData2 = {
+            rc_limit: rcLimit,
+            nonce,
+            operations,
+        };
+        const buffer = await this.serializer.serialize(activeData2);
+        return {
+            active: utils_1.encodeBase64(buffer),
+        };
+    }
+    /**
+     * Function to decode a transaction
+     */
+    async decodeTransaction(tx) {
+        if (!tx.active)
+            throw new Error("Active data is not defined");
+        return this.serializer.deserialize(tx.active);
+    }
+}
+exports.Signer = Signer;
+exports.default = Signer;
 
 
 /***/ }),
@@ -12544,38 +12544,38 @@ exports.default = Signer;
 /***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
-
-/*! koilib - MIT License (c) Julian Gonzalez (joticajulian@gmail.com) */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-const utils = __importStar(__webpack_require__(8593));
-const Contract_1 = __webpack_require__(9822);
-const Signer_1 = __webpack_require__(6991);
-const Provider_1 = __webpack_require__(5635);
-const Serializer_1 = __webpack_require__(7187);
-window.utils = utils;
-window.Contract = Contract_1.Contract;
-window.Signer = Signer_1.Signer;
-window.Provider = Provider_1.Provider;
-window.Serializer = Serializer_1.Serializer;
+
+/*! koilib - MIT License (c) Julian Gonzalez (joticajulian@gmail.com) */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const utils = __importStar(__webpack_require__(8593));
+const Contract_1 = __webpack_require__(9822);
+const Signer_1 = __webpack_require__(6991);
+const Provider_1 = __webpack_require__(5635);
+const Serializer_1 = __webpack_require__(7187);
+window.utils = utils;
+window.Contract = Contract_1.Contract;
+window.Signer = Signer_1.Signer;
+window.Provider = Provider_1.Provider;
+window.Serializer = Serializer_1.Serializer;
 
 
 /***/ }),
@@ -12584,257 +12584,257 @@ window.Serializer = Serializer_1.Serializer;
 /***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
-
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.ProtocolTypes = exports.Krc20Abi = exports.parseUnits = exports.formatUnits = exports.bitcoinAddress = exports.bitcoinDecode = exports.bitcoinEncode = exports.decodeBase64 = exports.encodeBase64 = exports.decodeBase58 = exports.encodeBase58 = exports.toHexString = exports.toUint8Array = void 0;
-const multibase = __importStar(__webpack_require__(6957));
-const sha256_1 = __webpack_require__(5374);
-const ripemd160_1 = __webpack_require__(7050);
-const krc20_proto_json_1 = __importDefault(__webpack_require__(7177));
-const protocol_proto_json_1 = __importDefault(__webpack_require__(6139));
-/**
- * Converts an hex string to Uint8Array
- */
-function toUint8Array(hex) {
-    const pairs = hex.match(/[\dA-F]{2}/gi);
-    if (!pairs)
-        throw new Error("Invalid hex");
-    return new Uint8Array(pairs.map((s) => parseInt(s, 16)) // convert to integers
-    );
-}
-exports.toUint8Array = toUint8Array;
-/**
- * Converts Uint8Array to hex string
- */
-function toHexString(buffer) {
-    return Array.from(buffer)
-        .map((n) => `0${Number(n).toString(16)}`.slice(-2))
-        .join("");
-}
-exports.toHexString = toHexString;
-/**
- * Encodes an Uint8Array in base58
- */
-function encodeBase58(buffer) {
-    return new TextDecoder().decode(multibase.encode("z", buffer)).slice(1);
-}
-exports.encodeBase58 = encodeBase58;
-/**
- * Decodes a buffer formatted in base58
- */
-function decodeBase58(bs58) {
-    return multibase.decode(`z${bs58}`);
-}
-exports.decodeBase58 = decodeBase58;
-/**
- * Encodes an Uint8Array in base64
- */
-function encodeBase64(buffer) {
-    return new TextDecoder().decode(multibase.encode("U", buffer)).slice(1);
-}
-exports.encodeBase64 = encodeBase64;
-/**
- * Decodes a buffer formatted in base64
- */
-function decodeBase64(bs64) {
-    return multibase.decode(`U${bs64}`);
-}
-exports.decodeBase64 = decodeBase64;
-/**
- * Encodes a public or private key in base58 using
- * the bitcoin format (see [Bitcoin Base58Check encoding](https://en.bitcoin.it/wiki/Base58Check_encoding)
- * and [Bitcoin WIF](https://en.bitcoin.it/wiki/Wallet_import_format)).
- *
- * For private keys this encode is also known as
- * wallet import format (WIF).
- */
-function bitcoinEncode(buffer, type, compressed = false) {
-    let bufferCheck;
-    let prefixBuffer;
-    let offsetChecksum;
-    if (type === "public") {
-        bufferCheck = new Uint8Array(25);
-        prefixBuffer = new Uint8Array(21);
-        bufferCheck[0] = 0;
-        prefixBuffer[0] = 0;
-        offsetChecksum = 21;
-    }
-    else {
-        if (compressed) {
-            bufferCheck = new Uint8Array(38);
-            prefixBuffer = new Uint8Array(34);
-            offsetChecksum = 34;
-            bufferCheck[33] = 1;
-            prefixBuffer[33] = 1;
-        }
-        else {
-            bufferCheck = new Uint8Array(37);
-            prefixBuffer = new Uint8Array(33);
-            offsetChecksum = 33;
-        }
-        bufferCheck[0] = 128;
-        prefixBuffer[0] = 128;
-    }
-    prefixBuffer.set(buffer, 1);
-    const firstHash = sha256_1.sha256(prefixBuffer);
-    const doubleHash = sha256_1.sha256(firstHash);
-    const checksum = new Uint8Array(4);
-    checksum.set(doubleHash.slice(0, 4));
-    bufferCheck.set(buffer, 1);
-    bufferCheck.set(checksum, offsetChecksum);
-    return encodeBase58(bufferCheck);
-}
-exports.bitcoinEncode = bitcoinEncode;
-/**
- * Decodes a public or private key formatted in base58 using
- * the bitcoin format (see [Bitcoin Base58Check encoding](https://en.bitcoin.it/wiki/Base58Check_encoding)
- * and [Bitcoin WIF](https://en.bitcoin.it/wiki/Wallet_import_format)).
- *
- * For private keys this encode is also known as
- * wallet import format (WIF).
- */
-function bitcoinDecode(value) {
-    const buffer = decodeBase58(value);
-    const privateKey = new Uint8Array(32);
-    const checksum = new Uint8Array(4);
-    // const prefix = buffer[0];
-    privateKey.set(buffer.slice(1, 33));
-    if (value[0] !== "5") {
-        // compressed
-        checksum.set(buffer.slice(34, 38));
-    }
-    else {
-        checksum.set(buffer.slice(33, 37));
-    }
-    // TODO: verify prefix and checksum
-    return privateKey;
-}
-exports.bitcoinDecode = bitcoinDecode;
-/**
- * Computes a bitcoin address, which is the format used in Koinos
- *
- * address = bitcoinEncode( ripemd160 ( sha256 ( publicKey ) ) )
- */
-function bitcoinAddress(publicKey) {
-    const hash = sha256_1.sha256(publicKey);
-    const hash160 = ripemd160_1.ripemd160(hash);
-    return bitcoinEncode(hash160, "public");
-}
-exports.bitcoinAddress = bitcoinAddress;
-/**
- * Function to format a number in a decimal point number
- * @example
- * ```js
- * const amount = formatUnits("123456", 8);
- * console.log(amount);
- * // '0.00123456'
- * ```
- */
-function formatUnits(value, decimals) {
-    let v = typeof value === "string" ? value : BigInt(value).toString();
-    const sign = v[0] === "-" ? "-" : "";
-    v = v.replace("-", "").padStart(decimals + 1, "0");
-    const integerPart = v
-        .substring(0, v.length - decimals)
-        .replace(/^0+(?=\d)/, "");
-    const decimalPart = v.substring(v.length - decimals);
-    return `${sign}${integerPart}.${decimalPart}`.replace(/(\.0+)?(0+)$/, "");
-}
-exports.formatUnits = formatUnits;
-/**
- * Function to format a decimal point number in an integer
- * @example
- * ```js
- * const amount = parseUnits("0.00123456", 8);
- * console.log(amount);
- * // '123456'
- * ```
- */
-function parseUnits(value, decimals) {
-    const sign = value[0] === "-" ? "-" : "";
-    // eslint-disable-next-line prefer-const
-    let [integerPart, decimalPart] = value
-        .replace("-", "")
-        .replace(",", ".")
-        .split(".");
-    if (!decimalPart)
-        decimalPart = "";
-    decimalPart = decimalPart.padEnd(decimals, "0");
-    return `${sign}${`${integerPart}${decimalPart}`.replace(/^0+(?=\d)/, "")}`;
-}
-exports.parseUnits = parseUnits;
-/**
- * ABI for tokens
- */
-exports.Krc20Abi = {
-    methods: {
-        name: {
-            entryPoint: 0x76ea4297,
-            input: "name_arguments",
-            output: "name_result",
-            readOnly: true,
-        },
-        symbol: {
-            entryPoint: 0x7e794b24,
-            input: "symbol_arguments",
-            output: "symbol_result",
-            readOnly: true,
-        },
-        decimals: {
-            entryPoint: 0x59dc15ce,
-            input: "decimals_arguments",
-            output: "decimals_result",
-            readOnly: true,
-        },
-        totalSupply: {
-            entryPoint: 0xcf2e8212,
-            input: "total_supply_arguments",
-            output: "total_supply_result",
-            readOnly: true,
-        },
-        balanceOf: {
-            entryPoint: 0x15619248,
-            input: "balance_of_arguments",
-            output: "balance_of_result",
-            readOnly: true,
-            defaultOutput: { value: "0" },
-        },
-        transfer: {
-            entryPoint: 0x62efa292,
-            input: "transfer_arguments",
-            output: "transfer_result",
-        },
-        mint: {
-            entryPoint: 0xc2f82bdc,
-            input: "mint_argumnets",
-            output: "mint_result",
-        },
-    },
-    types: krc20_proto_json_1.default,
-};
-exports.ProtocolTypes = protocol_proto_json_1.default;
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.ProtocolTypes = exports.Krc20Abi = exports.parseUnits = exports.formatUnits = exports.bitcoinAddress = exports.bitcoinDecode = exports.bitcoinEncode = exports.decodeBase64 = exports.encodeBase64 = exports.decodeBase58 = exports.encodeBase58 = exports.toHexString = exports.toUint8Array = void 0;
+const multibase = __importStar(__webpack_require__(6957));
+const sha256_1 = __webpack_require__(5374);
+const ripemd160_1 = __webpack_require__(7050);
+const krc20_proto_json_1 = __importDefault(__webpack_require__(7177));
+const protocol_proto_json_1 = __importDefault(__webpack_require__(6139));
+/**
+ * Converts an hex string to Uint8Array
+ */
+function toUint8Array(hex) {
+    const pairs = hex.match(/[\dA-F]{2}/gi);
+    if (!pairs)
+        throw new Error("Invalid hex");
+    return new Uint8Array(pairs.map((s) => parseInt(s, 16)) // convert to integers
+    );
+}
+exports.toUint8Array = toUint8Array;
+/**
+ * Converts Uint8Array to hex string
+ */
+function toHexString(buffer) {
+    return Array.from(buffer)
+        .map((n) => `0${Number(n).toString(16)}`.slice(-2))
+        .join("");
+}
+exports.toHexString = toHexString;
+/**
+ * Encodes an Uint8Array in base58
+ */
+function encodeBase58(buffer) {
+    return new TextDecoder().decode(multibase.encode("z", buffer)).slice(1);
+}
+exports.encodeBase58 = encodeBase58;
+/**
+ * Decodes a buffer formatted in base58
+ */
+function decodeBase58(bs58) {
+    return multibase.decode(`z${bs58}`);
+}
+exports.decodeBase58 = decodeBase58;
+/**
+ * Encodes an Uint8Array in base64
+ */
+function encodeBase64(buffer) {
+    return new TextDecoder().decode(multibase.encode("U", buffer)).slice(1);
+}
+exports.encodeBase64 = encodeBase64;
+/**
+ * Decodes a buffer formatted in base64
+ */
+function decodeBase64(bs64) {
+    return multibase.decode(`U${bs64}`);
+}
+exports.decodeBase64 = decodeBase64;
+/**
+ * Encodes a public or private key in base58 using
+ * the bitcoin format (see [Bitcoin Base58Check encoding](https://en.bitcoin.it/wiki/Base58Check_encoding)
+ * and [Bitcoin WIF](https://en.bitcoin.it/wiki/Wallet_import_format)).
+ *
+ * For private keys this encode is also known as
+ * wallet import format (WIF).
+ */
+function bitcoinEncode(buffer, type, compressed = false) {
+    let bufferCheck;
+    let prefixBuffer;
+    let offsetChecksum;
+    if (type === "public") {
+        bufferCheck = new Uint8Array(25);
+        prefixBuffer = new Uint8Array(21);
+        bufferCheck[0] = 0;
+        prefixBuffer[0] = 0;
+        offsetChecksum = 21;
+    }
+    else {
+        if (compressed) {
+            bufferCheck = new Uint8Array(38);
+            prefixBuffer = new Uint8Array(34);
+            offsetChecksum = 34;
+            bufferCheck[33] = 1;
+            prefixBuffer[33] = 1;
+        }
+        else {
+            bufferCheck = new Uint8Array(37);
+            prefixBuffer = new Uint8Array(33);
+            offsetChecksum = 33;
+        }
+        bufferCheck[0] = 128;
+        prefixBuffer[0] = 128;
+    }
+    prefixBuffer.set(buffer, 1);
+    const firstHash = sha256_1.sha256(prefixBuffer);
+    const doubleHash = sha256_1.sha256(firstHash);
+    const checksum = new Uint8Array(4);
+    checksum.set(doubleHash.slice(0, 4));
+    bufferCheck.set(buffer, 1);
+    bufferCheck.set(checksum, offsetChecksum);
+    return encodeBase58(bufferCheck);
+}
+exports.bitcoinEncode = bitcoinEncode;
+/**
+ * Decodes a public or private key formatted in base58 using
+ * the bitcoin format (see [Bitcoin Base58Check encoding](https://en.bitcoin.it/wiki/Base58Check_encoding)
+ * and [Bitcoin WIF](https://en.bitcoin.it/wiki/Wallet_import_format)).
+ *
+ * For private keys this encode is also known as
+ * wallet import format (WIF).
+ */
+function bitcoinDecode(value) {
+    const buffer = decodeBase58(value);
+    const privateKey = new Uint8Array(32);
+    const checksum = new Uint8Array(4);
+    // const prefix = buffer[0];
+    privateKey.set(buffer.slice(1, 33));
+    if (value[0] !== "5") {
+        // compressed
+        checksum.set(buffer.slice(34, 38));
+    }
+    else {
+        checksum.set(buffer.slice(33, 37));
+    }
+    // TODO: verify prefix and checksum
+    return privateKey;
+}
+exports.bitcoinDecode = bitcoinDecode;
+/**
+ * Computes a bitcoin address, which is the format used in Koinos
+ *
+ * address = bitcoinEncode( ripemd160 ( sha256 ( publicKey ) ) )
+ */
+function bitcoinAddress(publicKey) {
+    const hash = sha256_1.sha256(publicKey);
+    const hash160 = ripemd160_1.ripemd160(hash);
+    return bitcoinEncode(hash160, "public");
+}
+exports.bitcoinAddress = bitcoinAddress;
+/**
+ * Function to format a number in a decimal point number
+ * @example
+ * ```js
+ * const amount = formatUnits("123456", 8);
+ * console.log(amount);
+ * // '0.00123456'
+ * ```
+ */
+function formatUnits(value, decimals) {
+    let v = typeof value === "string" ? value : BigInt(value).toString();
+    const sign = v[0] === "-" ? "-" : "";
+    v = v.replace("-", "").padStart(decimals + 1, "0");
+    const integerPart = v
+        .substring(0, v.length - decimals)
+        .replace(/^0+(?=\d)/, "");
+    const decimalPart = v.substring(v.length - decimals);
+    return `${sign}${integerPart}.${decimalPart}`.replace(/(\.0+)?(0+)$/, "");
+}
+exports.formatUnits = formatUnits;
+/**
+ * Function to format a decimal point number in an integer
+ * @example
+ * ```js
+ * const amount = parseUnits("0.00123456", 8);
+ * console.log(amount);
+ * // '123456'
+ * ```
+ */
+function parseUnits(value, decimals) {
+    const sign = value[0] === "-" ? "-" : "";
+    // eslint-disable-next-line prefer-const
+    let [integerPart, decimalPart] = value
+        .replace("-", "")
+        .replace(",", ".")
+        .split(".");
+    if (!decimalPart)
+        decimalPart = "";
+    decimalPart = decimalPart.padEnd(decimals, "0");
+    return `${sign}${`${integerPart}${decimalPart}`.replace(/^0+(?=\d)/, "")}`;
+}
+exports.parseUnits = parseUnits;
+/**
+ * ABI for tokens
+ */
+exports.Krc20Abi = {
+    methods: {
+        name: {
+            entryPoint: 0x76ea4297,
+            input: "name_arguments",
+            output: "name_result",
+            readOnly: true,
+        },
+        symbol: {
+            entryPoint: 0x7e794b24,
+            input: "symbol_arguments",
+            output: "symbol_result",
+            readOnly: true,
+        },
+        decimals: {
+            entryPoint: 0x59dc15ce,
+            input: "decimals_arguments",
+            output: "decimals_result",
+            readOnly: true,
+        },
+        totalSupply: {
+            entryPoint: 0xcf2e8212,
+            input: "total_supply_arguments",
+            output: "total_supply_result",
+            readOnly: true,
+        },
+        balanceOf: {
+            entryPoint: 0x15619248,
+            input: "balance_of_arguments",
+            output: "balance_of_result",
+            readOnly: true,
+            defaultOutput: { value: "0" },
+        },
+        transfer: {
+            entryPoint: 0x62efa292,
+            input: "transfer_arguments",
+            output: "transfer_result",
+        },
+        mint: {
+            entryPoint: 0xc2f82bdc,
+            input: "mint_arguments",
+            output: "mint_result",
+        },
+    },
+    types: krc20_proto_json_1.default,
+};
+exports.ProtocolTypes = protocol_proto_json_1.default;
 
 
 /***/ }),