@leofcoin/codec-format-interface 1.4.3 → 1.5.1

package/dist/index.js

@@ -1,141 +1,1160 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var bs32 = require('@vandeurenglenn/base32');
-var bs58 = require('@vandeurenglenn/base58');
-var isHex = require('@vandeurenglenn/is-hex');
-var varint = require('varint');
-var createKeccakHash = require('keccak');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var bs32__default = /*#__PURE__*/_interopDefaultLegacy(bs32);
-var bs58__default = /*#__PURE__*/_interopDefaultLegacy(bs58);
-var isHex__default = /*#__PURE__*/_interopDefaultLegacy(isHex);
-var varint__default = /*#__PURE__*/_interopDefaultLegacy(varint);
-var createKeccakHash__default = /*#__PURE__*/_interopDefaultLegacy(createKeccakHash);
-
-class BasicInterface$1 {
-  handleDecode() {
-    if (!this.decode) throw new Error('bad implementation: needs decode func')
-    return this.decode()
-  }
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
 
-  handleEncode() {
-    if (!this.encode) throw new Error('bad implementation: needs encode func')
-    return this.encode()
-  }
-  isHex(string) {
-    return isHex__default["default"](string)
-  }
-  isBase32(string) {
-    return bs32__default["default"].isBase32(string)
-  }
-  isBase58(string) {
-    return bs58__default["default"].isBase58(string)
-  }
-  /**
-   * @param {String} encoded
-   */
-  fromBs32(encoded) {
-    this.encoded = bs32__default["default"].decode(encoded);
-    return this.handleDecode()
-  }
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
 
-  /**
-   * @param {String} encoded
-   */
-  fromBs58(encoded) {
-    this.encoded = bs58__default["default"].decode(encoded);
-    return this.handleDecode()
-  }
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise */
 
-  async toArray() {
-    const array = [];
-    for await (const value of this.encoded.values()) {
-      array.push(value);
-    }
-    return array
-  }
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
 
-  fromString(string) {
-    this.encoded = new Uint8Array(string.split(','));
-    return this.handleDecode()
-  }
+function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
 
-  fromArray(array) {
-    this.encoded = new Uint8Array([...array]);
-    return this.handleDecode()
-  }
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 
-  /**
-   * @param {Buffer} encoded
-   */
-  fromEncoded(encoded) {
-    this.encoded = encoded;
-    return this.handleDecode()
-  }
+function __awaiter$1(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
 
-  /**
-   * @param {String} encoded
-   */
-  fromHex(encoded) {
-    this.encoded = Buffer.from(encoded, 'hex');
-    return this.handleDecode()
-  }
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
 
-  async toString(encoding = 'utf8') {
-    if (!this.encoded) await this.handleEncode();
-    return this.encoded.toString(encoding)
-  }
+function __values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
 
-  /**
-   * @return {String} encoded
-   */
-  toHex() {
-    return this.toString('hex')
-  }
+function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+}
 
-  /**
-   * @return {String} encoded
-   */
-  async toBs32() {
-    if (!this.encoded) await this.handleEncode();
-    return bs32__default["default"].encode(this.encoded)
-  }
+function __asyncValues(o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+}
+
+// base-x encoding / decoding
+// Copyright (c) 2018 base-x contributors
+// Copyright (c) 2014-2018 The Bitcoin Core developers (base58.cpp)
+// Distributed under the MIT software license, see the accompanying
+// file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+var base$1 = function (ALPHABET) {
+    if (ALPHABET.length >= 255) {
+        throw new TypeError('Alphabet too long');
+    }
+    var BASE_MAP = new Uint8Array(256);
+    for (var j = 0; j < BASE_MAP.length; j++) {
+        BASE_MAP[j] = 255;
+    }
+    for (var i = 0; i < ALPHABET.length; i++) {
+        var x = ALPHABET.charAt(i);
+        var xc = x.charCodeAt(0);
+        if (BASE_MAP[xc] !== 255) {
+            throw new TypeError(x + ' is ambiguous');
+        }
+        BASE_MAP[xc] = i;
+    }
+    var BASE = ALPHABET.length;
+    var LEADER = ALPHABET.charAt(0);
+    var FACTOR = Math.log(BASE) / Math.log(256); // log(BASE) / log(256), rounded up
+    var iFACTOR = Math.log(256) / Math.log(BASE); // log(256) / log(BASE), rounded up
+    var encode = function (source) {
+        if (source instanceof Uint8Array) ;
+        else if (ArrayBuffer.isView(source)) {
+            source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+        }
+        else if (Array.isArray(source)) {
+            source = Uint8Array.from(source);
+        }
+        if (!(source instanceof Uint8Array)) {
+            throw new TypeError('Expected Uint8Array');
+        }
+        if (source.length === 0) {
+            return '';
+        }
+        // Skip & count leading zeroes.
+        var zeroes = 0;
+        var length = 0;
+        var pbegin = 0;
+        var pend = source.length;
+        while (pbegin !== pend && source[pbegin] === 0) {
+            pbegin++;
+            zeroes++;
+        }
+        // Allocate enough space in big-endian base58 representation.
+        var size = ((pend - pbegin) * iFACTOR + 1) >>> 0;
+        var b58 = new Uint8Array(size);
+        // Process the bytes.
+        while (pbegin !== pend) {
+            var carry = source[pbegin];
+            // Apply "b58 = b58 * 256 + ch".
+            var i = 0;
+            for (var it1 = size - 1; (carry !== 0 || i < length) && (it1 !== -1); it1--, i++) {
+                carry += (256 * b58[it1]) >>> 0;
+                b58[it1] = (carry % BASE) >>> 0;
+                carry = (carry / BASE) >>> 0;
+            }
+            if (carry !== 0) {
+                throw new Error('Non-zero carry');
+            }
+            length = i;
+            pbegin++;
+        }
+        // Skip leading zeroes in base58 result.
+        var it2 = size - length;
+        while (it2 !== size && b58[it2] === 0) {
+            it2++;
+        }
+        // Translate the result into a string.
+        var str = LEADER.repeat(zeroes);
+        for (; it2 < size; ++it2) {
+            str += ALPHABET.charAt(b58[it2]);
+        }
+        return str;
+    };
+    var decodeUnsafe = function (source) {
+        if (typeof source !== 'string') {
+            throw new TypeError('Expected String');
+        }
+        if (source.length === 0) {
+            return new Uint8Array();
+        }
+        var psz = 0;
+        // Skip and count leading '1's.
+        var zeroes = 0;
+        var length = 0;
+        while (source[psz] === LEADER) {
+            zeroes++;
+            psz++;
+        }
+        // Allocate enough space in big-endian base256 representation.
+        var size = (((source.length - psz) * FACTOR) + 1) >>> 0; // log(58) / log(256), rounded up.
+        var b256 = new Uint8Array(size);
+        // Process the characters.
+        while (source[psz]) {
+            // Decode character
+            var carry = BASE_MAP[source.charCodeAt(psz)];
+            // Invalid character
+            if (carry === 255) {
+                return;
+            }
+            var i = 0;
+            for (var it3 = size - 1; (carry !== 0 || i < length) && (it3 !== -1); it3--, i++) {
+                carry += (BASE * b256[it3]) >>> 0;
+                b256[it3] = (carry % 256) >>> 0;
+                carry = (carry / 256) >>> 0;
+            }
+            if (carry !== 0) {
+                throw new Error('Non-zero carry');
+            }
+            length = i;
+            psz++;
+        }
+        // Skip leading zeroes in b256.
+        var it4 = size - length;
+        while (it4 !== size && b256[it4] === 0) {
+            it4++;
+        }
+        var vch = new Uint8Array(zeroes + (size - it4));
+        var j = zeroes;
+        while (it4 !== size) {
+            vch[j++] = b256[it4++];
+        }
+        return vch;
+    };
+    var decode = function (string) {
+        var buffer = decodeUnsafe(string);
+        if (buffer) {
+            return buffer;
+        }
+        throw new Error('Non-base' + BASE + ' character');
+    };
+    return {
+        encode: encode,
+        decodeUnsafe: decodeUnsafe,
+        decode: decode
+    };
+};
+
+var base32 = 'abcdefghijklmnopqrstuvwxyz234567';
+var base32Hex = '0123456789abcdefghijklmnopqrstuv';
+var decode$2 = function (string, hex) {
+    if (hex === void 0) { hex = false; }
+    var decoder = hex ? base$1(base32Hex) : base$1(base32);
+    return decoder.decode(string);
+};
+var base32$1 = {
+    encode: function (uint8Array, hex) {
+        if (hex === void 0) { hex = false; }
+        var encoder = hex ? base$1(base32Hex) : base$1(base32);
+        return encoder.encode(uint8Array);
+    },
+    decode: decode$2,
+    isBase32: function (string, hex) {
+        if (hex === void 0) { hex = false; }
+        try {
+            decode$2(string, hex);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+};
+
+// base-x encoding / decoding
+// Copyright (c) 2018 base-x contributors
+// Copyright (c) 2014-2018 The Bitcoin Core developers (base58.cpp)
+// Distributed under the MIT software license, see the accompanying
+// file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+var base = function (ALPHABET) {
+    if (ALPHABET.length >= 255) {
+        throw new TypeError('Alphabet too long');
+    }
+    var BASE_MAP = new Uint8Array(256);
+    for (var j = 0; j < BASE_MAP.length; j++) {
+        BASE_MAP[j] = 255;
+    }
+    for (var i = 0; i < ALPHABET.length; i++) {
+        var x = ALPHABET.charAt(i);
+        var xc = x.charCodeAt(0);
+        if (BASE_MAP[xc] !== 255) {
+            throw new TypeError(x + ' is ambiguous');
+        }
+        BASE_MAP[xc] = i;
+    }
+    var BASE = ALPHABET.length;
+    var LEADER = ALPHABET.charAt(0);
+    var FACTOR = Math.log(BASE) / Math.log(256); // log(BASE) / log(256), rounded up
+    var iFACTOR = Math.log(256) / Math.log(BASE); // log(256) / log(BASE), rounded up
+    var encode = function (source) {
+        if (source instanceof Uint8Array) ;
+        else if (ArrayBuffer.isView(source)) {
+            source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+        }
+        else if (Array.isArray(source)) {
+            source = Uint8Array.from(source);
+        }
+        if (!(source instanceof Uint8Array)) {
+            throw new TypeError('Expected Uint8Array');
+        }
+        if (source.length === 0) {
+            return '';
+        }
+        // Skip & count leading zeroes.
+        var zeroes = 0;
+        var length = 0;
+        var pbegin = 0;
+        var pend = source.length;
+        while (pbegin !== pend && source[pbegin] === 0) {
+            pbegin++;
+            zeroes++;
+        }
+        // Allocate enough space in big-endian base58 representation.
+        var size = ((pend - pbegin) * iFACTOR + 1) >>> 0;
+        var b58 = new Uint8Array(size);
+        // Process the bytes.
+        while (pbegin !== pend) {
+            var carry = source[pbegin];
+            // Apply "b58 = b58 * 256 + ch".
+            var i = 0;
+            for (var it1 = size - 1; (carry !== 0 || i < length) && (it1 !== -1); it1--, i++) {
+                carry += (256 * b58[it1]) >>> 0;
+                b58[it1] = (carry % BASE) >>> 0;
+                carry = (carry / BASE) >>> 0;
+            }
+            if (carry !== 0) {
+                throw new Error('Non-zero carry');
+            }
+            length = i;
+            pbegin++;
+        }
+        // Skip leading zeroes in base58 result.
+        var it2 = size - length;
+        while (it2 !== size && b58[it2] === 0) {
+            it2++;
+        }
+        // Translate the result into a string.
+        var str = LEADER.repeat(zeroes);
+        for (; it2 < size; ++it2) {
+            str += ALPHABET.charAt(b58[it2]);
+        }
+        return str;
+    };
+    var decodeUnsafe = function (source) {
+        if (typeof source !== 'string') {
+            throw new TypeError('Expected String');
+        }
+        if (source.length === 0) {
+            return new Uint8Array();
+        }
+        var psz = 0;
+        // Skip and count leading '1's.
+        var zeroes = 0;
+        var length = 0;
+        while (source[psz] === LEADER) {
+            zeroes++;
+            psz++;
+        }
+        // Allocate enough space in big-endian base256 representation.
+        var size = (((source.length - psz) * FACTOR) + 1) >>> 0; // log(58) / log(256), rounded up.
+        var b256 = new Uint8Array(size);
+        // Process the characters.
+        while (source[psz]) {
+            // Decode character
+            var carry = BASE_MAP[source.charCodeAt(psz)];
+            // Invalid character
+            if (carry === 255) {
+                return;
+            }
+            var i = 0;
+            for (var it3 = size - 1; (carry !== 0 || i < length) && (it3 !== -1); it3--, i++) {
+                carry += (BASE * b256[it3]) >>> 0;
+                b256[it3] = (carry % 256) >>> 0;
+                carry = (carry / 256) >>> 0;
+            }
+            if (carry !== 0) {
+                throw new Error('Non-zero carry');
+            }
+            length = i;
+            psz++;
+        }
+        // Skip leading zeroes in b256.
+        var it4 = size - length;
+        while (it4 !== size && b256[it4] === 0) {
+            it4++;
+        }
+        var vch = new Uint8Array(zeroes + (size - it4));
+        var j = zeroes;
+        while (it4 !== size) {
+            vch[j++] = b256[it4++];
+        }
+        return vch;
+    };
+    var decode = function (string) {
+        var buffer = decodeUnsafe(string);
+        if (buffer) {
+            return buffer;
+        }
+        throw new Error('Non-base' + BASE + ' character');
+    };
+    return {
+        encode: encode,
+        decodeUnsafe: decodeUnsafe,
+        decode: decode
+    };
+};
+
+var ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+var base58 = base(ALPHABET);
+var decode$1 = function (string) { return base58.decode(string); };
+var base58$1 = {
+    encode: function (uint8Array) { return base58.encode(uint8Array); },
+    decode: decode$1,
+    isBase58: function (string) {
+        try {
+            decode$1(string);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+};
+
+/**
+ * @param {string}
+ */
+var isHex = (function (string) { return /^[A-F0-9]+$/i.test(string); });
+
+var BasicInterface$1 = /** @class */ (function () {
+    function BasicInterface() {
+    }
+    // get Codec(): Codec {}
+    BasicInterface.prototype.protoEncode = function (data) {
+        return __awaiter$1(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                // check schema
+                return [2 /*return*/, new TextEncoder().encode(data)];
+            });
+        });
+    };
+    BasicInterface.prototype.protoDecode = function (data) {
+        return __awaiter$1(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                // check schema
+                return [2 /*return*/, new TextDecoder().decode(data)];
+            });
+        });
+    };
+    BasicInterface.prototype.isHex = function (string) {
+        return isHex(string);
+    };
+    BasicInterface.prototype.isBase32 = function (string) {
+        return base32$1.isBase32(string);
+    };
+    BasicInterface.prototype.isBase58 = function (string) {
+        return base58$1.isBase58(string);
+    };
+    BasicInterface.prototype.fromBs32 = function (encoded) {
+        this.encoded = base32$1.decode(encoded);
+        return this.decode();
+    };
+    BasicInterface.prototype.fromBs58 = function (encoded) {
+        this.encoded = base58$1.decode(encoded);
+        return this.decode();
+    };
+    BasicInterface.prototype.toArray = function () {
+        var _a, e_1, _b, _c;
+        return __awaiter$1(this, void 0, void 0, function () {
+            var array, _d, _e, _f, value, e_1_1;
+            return __generator(this, function (_g) {
+                switch (_g.label) {
+                    case 0:
+                        array = [];
+                        _g.label = 1;
+                    case 1:
+                        _g.trys.push([1, 6, 7, 12]);
+                        _d = true, _e = __asyncValues(this.encoded.values());
+                        _g.label = 2;
+                    case 2: return [4 /*yield*/, _e.next()];
+                    case 3:
+                        if (!(_f = _g.sent(), _a = _f.done, !_a)) return [3 /*break*/, 5];
+                        _c = _f.value;
+                        _d = false;
+                        try {
+                            value = _c;
+                            array.push(value);
+                        }
+                        finally {
+                            _d = true;
+                        }
+                        _g.label = 4;
+                    case 4: return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 12];
+                    case 6:
+                        e_1_1 = _g.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 12];
+                    case 7:
+                        _g.trys.push([7, , 10, 11]);
+                        if (!(!_d && !_a && (_b = _e["return"]))) return [3 /*break*/, 9];
+                        return [4 /*yield*/, _b.call(_e)];
+                    case 8:
+                        _g.sent();
+                        _g.label = 9;
+                    case 9: return [3 /*break*/, 11];
+                    case 10:
+                        if (e_1) throw e_1.error;
+                        return [7 /*endfinally*/];
+                    case 11: return [7 /*endfinally*/];
+                    case 12: return [2 /*return*/, array];
+                }
+            });
+        });
+    };
+    BasicInterface.prototype.fromString = function (string) {
+        var array = string.split(',');
+        var arrayLike = array.map(function (string) { return Number(string); });
+        this.encoded = Uint8Array.from(arrayLike);
+        return this.decode();
+    };
+    BasicInterface.prototype.fromArray = function (array) {
+        this.encoded = Uint8Array.from(__spreadArray([], array, true));
+        return this.decode();
+    };
+    BasicInterface.prototype.fromEncoded = function (encoded) {
+        this.encoded = encoded;
+        return this.decode();
+    };
+    BasicInterface.prototype.fromHex = function (encoded) {
+        this.encoded = Buffer.from(encoded, 'hex');
+        return this.decode();
+    };
+    BasicInterface.prototype.toString = function (encoding) {
+        if (encoding === void 0) { encoding = 'utf8'; }
+        return __awaiter$1(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!!this.encoded) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.encode()];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [2 /*return*/, this.encoded.toString(encoding)];
+                }
+            });
+        });
+    };
+    /**
+     * @return {String} encoded
+     */
+    BasicInterface.prototype.toHex = function () {
+        return this.toString('hex');
+    };
+    /**
+     * @return {String} encoded
+     */
+    BasicInterface.prototype.toBs32 = function () {
+        return __awaiter$1(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!!this.encoded) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.encode()];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [2 /*return*/, base32$1.encode(this.encoded)];
+                }
+            });
+        });
+    };
+    /**
+     * @return {String} encoded
+     */
+    BasicInterface.prototype.toBs58 = function () {
+        return __awaiter$1(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!!this.encoded) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.encode()];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [2 /*return*/, base58$1.encode(this.encoded)];
+                }
+            });
+        });
+    };
+    /**
+     * @param {Object} data
+     */
+    BasicInterface.prototype.create = function (data) {
+        var _a;
+        var decoded = {};
+        if (((_a = this.keys) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+            var _loop_1 = function (key) {
+                var _c;
+                Object.defineProperties(decoded, (_c = {},
+                    _c[key] = {
+                        enumerable: true,
+                        configurable: true,
+                        set: function (value) { return data[key]; },
+                        get: function () { return data[key]; }
+                    },
+                    _c));
+            };
+            for (var _i = 0, _b = this.keys; _i < _b.length; _i++) {
+                var key = _b[_i];
+                _loop_1(key);
+            }
+            this.decoded = decoded;
+            return this.encode();
+        }
+    };
+    return BasicInterface;
+}());
+
+/*!
+ * hash-wasm (https://www.npmjs.com/package/hash-wasm)
+ * (c) Dani Biro
+ * @license MIT
+ */
+
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
 
-  /**
-   * @return {String} encoded
-   */
-  async toBs58() {
-    if (!this.encoded) await this.handleEncode();
-    return bs58__default["default"].encode(this.encoded)
-  }
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
 
-  /**
-   * @param {Object} data
-   */
-  create(data) {
-    const decoded = {};
-    if (this.keys?.length > 0) {
-      for (const key of this.keys) {
-        Object.defineProperties(decoded, {
-          [key]: {
-            enumerable: true,
-            configurable: true,
-            set: (val) => value = data[key],
-            get: () => data[key]
-          }
-        });
-      }
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
 
-      this.decoded = decoded;
-      return this.encode()
-    }
-  }
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+class Mutex {
+    constructor() {
+        this.mutex = Promise.resolve();
+    }
+    lock() {
+        let begin = () => { };
+        this.mutex = this.mutex.then(() => new Promise(begin));
+        return new Promise((res) => {
+            begin = res;
+        });
+    }
+    dispatch(fn) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const unlock = yield this.lock();
+            try {
+                return yield Promise.resolve(fn());
+            }
+            finally {
+                unlock();
+            }
+        });
+    }
+}
+
+/* eslint-disable import/prefer-default-export */
+/* eslint-disable no-bitwise */
+var _a;
+function getGlobal() {
+    if (typeof globalThis !== 'undefined')
+        return globalThis;
+    // eslint-disable-next-line no-restricted-globals
+    if (typeof self !== 'undefined')
+        return self;
+    if (typeof window !== 'undefined')
+        return window;
+    return global;
+}
+const globalObject = getGlobal();
+const nodeBuffer = (_a = globalObject.Buffer) !== null && _a !== void 0 ? _a : null;
+const textEncoder = globalObject.TextEncoder ? new globalObject.TextEncoder() : null;
+function hexCharCodesToInt(a, b) {
+    return (((a & 0xF) + ((a >> 6) | ((a >> 3) & 0x8))) << 4) | ((b & 0xF) + ((b >> 6) | ((b >> 3) & 0x8)));
+}
+function writeHexToUInt8(buf, str) {
+    const size = str.length >> 1;
+    for (let i = 0; i < size; i++) {
+        const index = i << 1;
+        buf[i] = hexCharCodesToInt(str.charCodeAt(index), str.charCodeAt(index + 1));
+    }
+}
+function hexStringEqualsUInt8(str, buf) {
+    if (str.length !== buf.length * 2) {
+        return false;
+    }
+    for (let i = 0; i < buf.length; i++) {
+        const strIndex = i << 1;
+        if (buf[i] !== hexCharCodesToInt(str.charCodeAt(strIndex), str.charCodeAt(strIndex + 1))) {
+            return false;
+        }
+    }
+    return true;
+}
+const alpha = 'a'.charCodeAt(0) - 10;
+const digit = '0'.charCodeAt(0);
+function getDigestHex(tmpBuffer, input, hashLength) {
+    let p = 0;
+    /* eslint-disable no-plusplus */
+    for (let i = 0; i < hashLength; i++) {
+        let nibble = input[i] >>> 4;
+        tmpBuffer[p++] = nibble > 9 ? nibble + alpha : nibble + digit;
+        nibble = input[i] & 0xF;
+        tmpBuffer[p++] = nibble > 9 ? nibble + alpha : nibble + digit;
+    }
+    /* eslint-enable no-plusplus */
+    return String.fromCharCode.apply(null, tmpBuffer);
+}
+const getUInt8Buffer = nodeBuffer !== null
+    ? (data) => {
+        if (typeof data === 'string') {
+            const buf = nodeBuffer.from(data, 'utf8');
+            return new Uint8Array(buf.buffer, buf.byteOffset, buf.length);
+        }
+        if (nodeBuffer.isBuffer(data)) {
+            return new Uint8Array(data.buffer, data.byteOffset, data.length);
+        }
+        if (ArrayBuffer.isView(data)) {
+            return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        }
+        throw new Error('Invalid data type!');
+    }
+    : (data) => {
+        if (typeof data === 'string') {
+            return textEncoder.encode(data);
+        }
+        if (ArrayBuffer.isView(data)) {
+            return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        }
+        throw new Error('Invalid data type!');
+    };
+const base64Chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const base64Lookup = new Uint8Array(256);
+for (let i = 0; i < base64Chars.length; i++) {
+    base64Lookup[base64Chars.charCodeAt(i)] = i;
+}
+function getDecodeBase64Length(data) {
+    let bufferLength = Math.floor(data.length * 0.75);
+    const len = data.length;
+    if (data[len - 1] === '=') {
+        bufferLength -= 1;
+        if (data[len - 2] === '=') {
+            bufferLength -= 1;
+        }
+    }
+    return bufferLength;
+}
+function decodeBase64(data) {
+    const bufferLength = getDecodeBase64Length(data);
+    const len = data.length;
+    const bytes = new Uint8Array(bufferLength);
+    let p = 0;
+    for (let i = 0; i < len; i += 4) {
+        const encoded1 = base64Lookup[data.charCodeAt(i)];
+        const encoded2 = base64Lookup[data.charCodeAt(i + 1)];
+        const encoded3 = base64Lookup[data.charCodeAt(i + 2)];
+        const encoded4 = base64Lookup[data.charCodeAt(i + 3)];
+        bytes[p] = (encoded1 << 2) | (encoded2 >> 4);
+        p += 1;
+        bytes[p] = ((encoded2 & 15) << 4) | (encoded3 >> 2);
+        p += 1;
+        bytes[p] = ((encoded3 & 3) << 6) | (encoded4 & 63);
+        p += 1;
+    }
+    return bytes;
+}
+
+const MAX_HEAP = 16 * 1024;
+const WASM_FUNC_HASH_LENGTH = 4;
+const wasmMutex = new Mutex();
+const wasmModuleCache = new Map();
+function WASMInterface(binary, hashLength) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let wasmInstance = null;
+        let memoryView = null;
+        let initialized = false;
+        if (typeof WebAssembly === 'undefined') {
+            throw new Error('WebAssembly is not supported in this environment!');
+        }
+        const writeMemory = (data, offset = 0) => {
+            memoryView.set(data, offset);
+        };
+        const getMemory = () => memoryView;
+        const getExports = () => wasmInstance.exports;
+        const setMemorySize = (totalSize) => {
+            wasmInstance.exports.Hash_SetMemorySize(totalSize);
+            const arrayOffset = wasmInstance.exports.Hash_GetBuffer();
+            const memoryBuffer = wasmInstance.exports.memory.buffer;
+            memoryView = new Uint8Array(memoryBuffer, arrayOffset, totalSize);
+        };
+        const getStateSize = () => {
+            const view = new DataView(wasmInstance.exports.memory.buffer);
+            const stateSize = view.getUint32(wasmInstance.exports.STATE_SIZE, true);
+            return stateSize;
+        };
+        const loadWASMPromise = wasmMutex.dispatch(() => __awaiter(this, void 0, void 0, function* () {
+            if (!wasmModuleCache.has(binary.name)) {
+                const asm = decodeBase64(binary.data);
+                const promise = WebAssembly.compile(asm);
+                wasmModuleCache.set(binary.name, promise);
+            }
+            const module = yield wasmModuleCache.get(binary.name);
+            wasmInstance = yield WebAssembly.instantiate(module, {
+            // env: {
+            //   emscripten_memcpy_big: (dest, src, num) => {
+            //     const memoryBuffer = wasmInstance.exports.memory.buffer;
+            //     const memView = new Uint8Array(memoryBuffer, 0);
+            //     memView.set(memView.subarray(src, src + num), dest);
+            //   },
+            //   print_memory: (offset, len) => {
+            //     const memoryBuffer = wasmInstance.exports.memory.buffer;
+            //     const memView = new Uint8Array(memoryBuffer, 0);
+            //     console.log('print_int32', memView.subarray(offset, offset + len));
+            //   },
+            // },
+            });
+            // wasmInstance.exports._start();
+        }));
+        const setupInterface = () => __awaiter(this, void 0, void 0, function* () {
+            if (!wasmInstance) {
+                yield loadWASMPromise;
+            }
+            const arrayOffset = wasmInstance.exports.Hash_GetBuffer();
+            const memoryBuffer = wasmInstance.exports.memory.buffer;
+            memoryView = new Uint8Array(memoryBuffer, arrayOffset, MAX_HEAP);
+        });
+        const init = (bits = null) => {
+            initialized = true;
+            wasmInstance.exports.Hash_Init(bits);
+        };
+        const updateUInt8Array = (data) => {
+            let read = 0;
+            while (read < data.length) {
+                const chunk = data.subarray(read, read + MAX_HEAP);
+                read += chunk.length;
+                memoryView.set(chunk);
+                wasmInstance.exports.Hash_Update(chunk.length);
+            }
+        };
+        const update = (data) => {
+            if (!initialized) {
+                throw new Error('update() called before init()');
+            }
+            const Uint8Buffer = getUInt8Buffer(data);
+            updateUInt8Array(Uint8Buffer);
+        };
+        const digestChars = new Uint8Array(hashLength * 2);
+        const digest = (outputType, padding = null) => {
+            if (!initialized) {
+                throw new Error('digest() called before init()');
+            }
+            initialized = false;
+            wasmInstance.exports.Hash_Final(padding);
+            if (outputType === 'binary') {
+                // the data is copied to allow GC of the original memory object
+                return memoryView.slice(0, hashLength);
+            }
+            return getDigestHex(digestChars, memoryView, hashLength);
+        };
+        const save = () => {
+            if (!initialized) {
+                throw new Error('save() can only be called after init() and before digest()');
+            }
+            const stateOffset = wasmInstance.exports.Hash_GetState();
+            const stateLength = getStateSize();
+            const memoryBuffer = wasmInstance.exports.memory.buffer;
+            const internalState = new Uint8Array(memoryBuffer, stateOffset, stateLength);
+            // prefix is 4 bytes from SHA1 hash of the WASM binary
+            // it is used to detect incompatible internal states between different versions of hash-wasm
+            const prefixedState = new Uint8Array(WASM_FUNC_HASH_LENGTH + stateLength);
+            writeHexToUInt8(prefixedState, binary.hash);
+            prefixedState.set(internalState, WASM_FUNC_HASH_LENGTH);
+            return prefixedState;
+        };
+        const load = (state) => {
+            if (!(state instanceof Uint8Array)) {
+                throw new Error('load() expects an Uint8Array generated by save()');
+            }
+            const stateOffset = wasmInstance.exports.Hash_GetState();
+            const stateLength = getStateSize();
+            const overallLength = WASM_FUNC_HASH_LENGTH + stateLength;
+            const memoryBuffer = wasmInstance.exports.memory.buffer;
+            if (state.length !== overallLength) {
+                throw new Error(`Bad state length (expected ${overallLength} bytes, got ${state.length})`);
+            }
+            if (!hexStringEqualsUInt8(binary.hash, state.subarray(0, WASM_FUNC_HASH_LENGTH))) {
+                throw new Error('This state was written by an incompatible hash implementation');
+            }
+            const internalState = state.subarray(WASM_FUNC_HASH_LENGTH);
+            new Uint8Array(memoryBuffer, stateOffset, stateLength).set(internalState);
+            initialized = true;
+        };
+        const isDataShort = (data) => {
+            if (typeof data === 'string') {
+                // worst case is 4 bytes / char
+                return data.length < MAX_HEAP / 4;
+            }
+            return data.byteLength < MAX_HEAP;
+        };
+        let canSimplify = isDataShort;
+        switch (binary.name) {
+            case 'argon2':
+            case 'scrypt':
+                canSimplify = () => true;
+                break;
+            case 'blake2b':
+            case 'blake2s':
+                // if there is a key at blake2 then cannot simplify
+                canSimplify = (data, initParam) => initParam <= 512 && isDataShort(data);
+                break;
+            case 'blake3':
+                // if there is a key at blake3 then cannot simplify
+                canSimplify = (data, initParam) => initParam === 0 && isDataShort(data);
+                break;
+            case 'xxhash64': // cannot simplify
+            case 'xxhash3':
+            case 'xxhash128':
+                canSimplify = () => false;
+                break;
+        }
+        // shorthand for (init + update + digest) for better performance
+        const calculate = (data, initParam = null, digestParam = null) => {
+            if (!canSimplify(data, initParam)) {
+                init(initParam);
+                update(data);
+                return digest('hex', digestParam);
+            }
+            const buffer = getUInt8Buffer(data);
+            memoryView.set(buffer);
+            wasmInstance.exports.Hash_Calculate(buffer.length, initParam, digestParam);
+            return getDigestHex(digestChars, memoryView, hashLength);
+        };
+        yield setupInterface();
+        return {
+            getMemory,
+            writeMemory,
+            getExports,
+            setMemorySize,
+            init,
+            update,
+            digest,
+            save,
+            load,
+            calculate,
+            hashLength,
+        };
+    });
+}
+
+new Mutex();
+
+new Mutex();
+
+new Mutex();
+
+new Mutex();
+
+new Mutex();
+
+new Mutex();
+
+new Mutex();
+
+new Mutex();
+
+new Mutex();
+
+var name$b = "sha3";
+var data$b = "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";
+var hash$b = "ec266d91";
+var wasmJson$b = {
+	name: name$b,
+	data: data$b,
+	hash: hash$b
+};
+
+new Mutex();
+
+new Mutex();
+function validateBits(bits) {
+    if (![224, 256, 384, 512].includes(bits)) {
+        return new Error('Invalid variant! Valid values: 224, 256, 384, 512');
+    }
+    return null;
+}
+/**
+ * Creates a new Keccak hash instance
+ * @param bits Number of output bits. Valid values: 224, 256, 384, 512
+ */
+function createKeccak(bits = 512) {
+    if (validateBits(bits)) {
+        return Promise.reject(validateBits(bits));
+    }
+    const outputSize = bits / 8;
+    return WASMInterface(wasmJson$b, outputSize).then((wasm) => {
+        wasm.init(bits);
+        const obj = {
+            init: () => { wasm.init(bits); return obj; },
+            update: (data) => { wasm.update(data); return obj; },
+            digest: (outputType) => wasm.digest(outputType, 0x01),
+            save: () => wasm.save(),
+            load: (data) => { wasm.load(data); return obj; },
+            blockSize: 200 - 2 * outputSize,
+            digestSize: outputSize,
+        };
+        return obj;
+    });
+}
+
+new Mutex();
+
+new Mutex();
+
+new Mutex();
+
+new Mutex();
+
+new Mutex();
+
+new Mutex();
+
+new Mutex();
+
+new Mutex();
+
+new Mutex();
+
+new Mutex();
+
+new Mutex();
+
+var encode_1 = encode;
+
+var MSB$1 = 0x80
+  , REST$1 = 0x7F
+  , MSBALL = ~REST$1
+  , INT = Math.pow(2, 31);
+
+function encode(num, out, offset) {
+  if (Number.MAX_SAFE_INTEGER && num > Number.MAX_SAFE_INTEGER) {
+    encode.bytes = 0;
+    throw new RangeError('Could not encode varint')
+  }
+  out = out || [];
+  offset = offset || 0;
+  var oldOffset = offset;
+
+  while(num >= INT) {
+    out[offset++] = (num & 0xFF) | MSB$1;
+    num /= 128;
+  }
+  while(num & MSBALL) {
+    out[offset++] = (num & 0xFF) | MSB$1;
+    num >>>= 7;
+  }
+  out[offset] = num | 0;
+  
+  encode.bytes = offset - oldOffset + 1;
+  
+  return out
 }
 
+var decode = read;
+
+var MSB = 0x80
+  , REST = 0x7F;
+
+function read(buf, offset) {
+  var res    = 0
+    , offset = offset || 0
+    , shift  = 0
+    , counter = offset
+    , b
+    , l = buf.length;
+
+  do {
+    if (counter >= l || shift > 49) {
+      read.bytes = 0;
+      throw new RangeError('Could not decode varint')
+    }
+    b = buf[counter++];
+    res += shift < 28
+      ? (b & REST) << shift
+      : (b & REST) * Math.pow(2, shift);
+    shift += 7;
+  } while (b >= MSB)
+
+  read.bytes = counter - offset;
+
+  return res
+}
+
+var N1 = Math.pow(2,  7);
+var N2 = Math.pow(2, 14);
+var N3 = Math.pow(2, 21);
+var N4 = Math.pow(2, 28);
+var N5 = Math.pow(2, 35);
+var N6 = Math.pow(2, 42);
+var N7 = Math.pow(2, 49);
+var N8 = Math.pow(2, 56);
+var N9 = Math.pow(2, 63);
+
+var length = function (value) {
+  return (
+    value < N1 ? 1
+  : value < N2 ? 2
+  : value < N3 ? 3
+  : value < N4 ? 4
+  : value < N5 ? 5
+  : value < N6 ? 6
+  : value < N7 ? 7
+  : value < N8 ? 8
+  : value < N9 ? 9
+  :              10
+  )
+};
+
+var varint = {
+    encode: encode_1
+  , decode: decode
+  , encodingLength: length
+};
+
 var codecs = {
   // just a hash
   'disco-hash': {
@@ -224,125 +1243,138 @@ var codecs = {
   }
 };
 
-class PeernetCodec extends BasicInterface$1 {
-  get codecs() {
-    return {...globalThis.peernet.codecs, ...codecs}
-  }
-  constructor(buffer) {
-    super();
-    if (buffer) {
-      if (buffer instanceof Uint8Array) {
-        const codec = varint__default["default"].decode(buffer);
-        const name = this.getCodecName(codec);
-        if (name) {
-          this.name = name;
-          this.encoded = buffer;
-          this.decode(buffer);
-        } else {
-          this.encode(buffer);
-        }
-      } else if (buffer instanceof ArrayBuffer) {
-        const encoded = new Uint8Array(buffer.byteLength);
-
-        for (let i = 0; i < buffer.byteLength; i++) {
-          encoded[i] = buffer[i];
+var Codec$1 = /** @class */ (function (_super) {
+    __extends(Codec, _super);
+    function Codec(buffer) {
+        var _this = _super.call(this) || this;
+        if (buffer) {
+            if (buffer instanceof Uint8Array) {
+                var codec = varint.decode(buffer);
+                var name_1 = _this.getCodecName(codec);
+                if (name_1) {
+                    _this.name = name_1;
+                    _this.encoded = buffer;
+                    _this.decode(buffer);
+                }
+                else {
+                    _this.encode(buffer);
+                }
+            }
+            else if (buffer instanceof ArrayBuffer) {
+                var encoded = new Uint8Array(buffer.byteLength);
+                for (var i = 0; i < buffer.byteLength; i++) {
+                    encoded[i] = buffer[i];
+                }
+                _this.encoded = encoded;
+                // this.encoded = new Uint8Array(buffer, buffer.byteOffset, buffer.byteLength)
+                _this.decode(buffer);
+                return _this;
+            }
+            if (typeof buffer === 'string') {
+                if (_this.codecs[buffer])
+                    _this.fromName(buffer);
+                else if (_this.isHex(buffer))
+                    _this.fromHex(buffer);
+                else if (_this.isBase32(buffer))
+                    _this.fromBs32(buffer);
+                else if (_this.isBase58(buffer))
+                    _this.fromBs58(buffer);
+                else
+                    throw new Error("unsupported string ".concat(buffer));
+            }
+            if (!isNaN(buffer))
+                if (_this.codecs[_this.getCodecName(buffer)])
+                    _this.fromCodec(buffer);
         }
-        this.encoded = encoded;
-        // this.encoded = new Uint8Array(buffer, buffer.byteOffset, buffer.byteLength)
-        this.decode(buffer);
-        return
-      }
-      if (typeof buffer === 'string') {
-        if (this.codecs[buffer]) this.fromName(buffer);
-        else if (this.isHex(buffer)) this.fromHex(buffer);
-        else if (this.isBase32(buffer)) this.fromBs32(buffer);
-        else if (this.isBase58(buffer)) this.fromBs58(buffer);
-        else throw new Error(`unsupported string ${buffer}`)
-      }
-      if (!isNaN(buffer)) if (this.codecs[this.getCodecName(buffer)]) this.fromCodec(buffer);
+        return _this;
     }
-  }
-
-  fromEncoded(encoded) {
-    const codec = varint__default["default"].decode(encoded);
-    const name = this.getCodecName(codec);
-    this.name = name;
-    this.encoded = encoded;
-    this.decode(encoded);
-  }
-
-  getCodec(name) {
-    return this.codecs[name].codec
-  }
-
-  getCodecName(codec) {
-    return Object.keys(this.codecs).reduce((p, c) => {
-      const item = this.codecs[c];
-      if (item.codec === codec) return c;
-      else return p;
-    }, undefined)
-  }
-
-  getHashAlg(name) {
-    return this.codecs[name].hashAlg
-  }
-
-  fromCodec(codec) {
-    this.name = this.getCodecName(codec);
-    this.hashAlg = this.getHashAlg(this.name);
-
-    this.codec = this.getCodec(this.name);
-    this.codecBuffer = varint__default["default"].encode(codec);
-  }
-
-  fromName(name) {
-    const codec = this.getCodec(name);
-    this.name = name;
-    this.codec = codec;
-    this.hashAlg = this.getHashAlg(name);
-    this.codecBuffer = varint__default["default"].encode(codec);
-  }
-
-  decode() {
-    const codec = varint__default["default"].decode(this.encoded);
-    this.fromCodec(codec);
-  }
-
-  encode() {
-    const codec = varint__default["default"].encode(this.decoded);
-    this.encoded = codec;
-    return this.encoded
-  }
-}
+    Object.defineProperty(Codec.prototype, "codecs", {
+        get: function () {
+            return __assign(__assign({}, globalThis.peernet.codecs), codecs);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Codec.prototype.fromEncoded = function (encoded) {
+        var codec = varint.decode(encoded);
+        var name = this.getCodecName(codec);
+        this.name = name;
+        this.encoded = encoded;
+        this.decode(encoded);
+    };
+    Codec.prototype.getCodec = function (name) {
+        return this.codecs[name].codec;
+    };
+    Codec.prototype.getCodecName = function (codec) {
+        var _this = this;
+        return Object.keys(this.codecs).reduce(function (p, c) {
+            var item = _this.codecs[c];
+            if (item.codec === codec)
+                return c;
+            else
+                return p;
+        }, undefined);
+    };
+    Codec.prototype.getHashAlg = function (name) {
+        return this.codecs[name].hashAlg;
+    };
+    Codec.prototype.fromCodec = function (codec) {
+        this.name = this.getCodecName(codec);
+        this.hashAlg = this.getHashAlg(this.name);
+        this.codec = this.getCodec(this.name);
+        this.codecBuffer = varint.encode(codec);
+    };
+    Codec.prototype.fromName = function (name) {
+        var codec = this.getCodec(name);
+        this.name = name;
+        this.codec = codec;
+        this.hashAlg = this.getHashAlg(name);
+        this.codecBuffer = varint.encode(codec);
+    };
+    Codec.prototype.decode = function () {
+        var codec = varint.decode(this.encoded);
+        this.fromCodec(codec);
+    };
+    Codec.prototype.encode = function () {
+        var codec = varint.encode(this.decoded);
+        this.encoded = codec;
+        return this.encoded;
+    };
+    return Codec;
+}(BasicInterface$1));
 
-class CodecHash$1 extends BasicInterface$1 {
+let CodecHash$1 = class CodecHash extends BasicInterface$1 {
   constructor(buffer, options = {}) {
     super();
     if (options.name) this.name = options.name;
     else this.name = 'disco-hash';
     if (options.codecs) this.codecs = options.codecs;
-    if (buffer) {
-      if (buffer instanceof Uint8Array) {
-        this.discoCodec = new PeernetCodec(buffer, this.codecs);
+    return this.init(buffer)
+  }
+
+  async init(uint8Array) {
+    if (uint8Array) {
+      if (uint8Array instanceof Uint8Array) {
+        this.discoCodec = new Codec$1(uint8Array, this.codecs);
         const name = this.discoCodec.name;
 
         if (name) {
           this.name = name;
-          this.decode(buffer);
+          this.decode(uint8Array);
         } else {
-          this.encode(buffer);
+          await this.encode(uint8Array);
         }
       }
 
-      if (typeof buffer === 'string') {
-        if (this.isHex(buffer)) this.fromHex(buffer);
-        if (this.isBase32(buffer)) this.fromBs32(buffer);
-        else if (this.isBase58(buffer)) this.fromBs58(buffer);
-        else throw new Error(`unsupported string ${buffer}`)
-      } else if (typeof buffer === 'object') this.fromJSON(buffer);
+      if (typeof uint8Array === 'string') {
+        if (this.isHex(uint8Array)) await this.fromHex(uint8Array);
+        if (this.isBase32(uint8Array)) await this.fromBs32(uint8Array);
+        else if (this.isBase58(uint8Array)) await this.fromBs58(uint8Array);
+        else throw new Error(`unsupported string ${uint8Array}`)
+      } else if (typeof uint8Array === 'object') await this.fromJSON(uint8Array);
     }
+    return this
   }
-
   get prefix() {
     const length = this.length;
     const uint8Array = new Uint8Array(length.length + this.discoCodec.codecBuffer.length);
@@ -353,7 +1385,7 @@ class CodecHash$1 extends BasicInterface$1 {
   }
 
   get length() {
-    return varint__default["default"].encode(this.size)
+    return varint.encode(this.size)
   }
 
   get buffer() {
@@ -368,17 +1400,25 @@ class CodecHash$1 extends BasicInterface$1 {
     return this.encode(Buffer.from(JSON.stringify(json)))
   }
 
-  encode(buffer, name) {
+  async encode(buffer, name) {
     if (!this.name && name) this.name = name;
     if (!buffer) buffer = this.buffer;
-    this.discoCodec = new PeernetCodec(this.name, this.codecs);
+    this.discoCodec = new Codec$1(this.name, this.codecs);
     this.discoCodec.fromName(this.name);
     let hashAlg = this.discoCodec.hashAlg;
+    const hashVariant = Number(hashAlg.split('-')[hashAlg.split('-').length - 1]);
+    
     if (hashAlg.includes('dbl')) {
       hashAlg = hashAlg.replace('dbl-', '');
-      buffer = createKeccakHash__default["default"](hashAlg.replace('-', '')).update(buffer).digest();
+      const hasher = await createKeccak(hashVariant);
+      await hasher.init();
+      hasher.update(buffer);
+      buffer = hasher.digest('binary');
     }
-    this.digest = createKeccakHash__default["default"](hashAlg.replace('-', '')).update(buffer).digest();
+    const hasher = await createKeccak(hashVariant);
+    await hasher.init();
+    hasher.update(buffer);
+    this.digest = hasher.digest('binary');
     this.size = this.digest.length;
 
     this.codec = this.discoCodec.encode();
@@ -392,13 +1432,13 @@ class CodecHash$1 extends BasicInterface$1 {
     return this.encoded
   }
 
-  validate(buffer) {
+  async validate(buffer) {
     if (Buffer.isBuffer(buffer)) {
-      const codec = varint__default["default"].decode(buffer);
+      const codec = varint.decode(buffer);
       if (this.codecs[codec]) {
         this.decode(buffer);
       } else {
-        this.encode(buffer);
+        await this.encode(buffer);
       }
     }
     if (typeof buffer === 'string') {
@@ -410,13 +1450,13 @@ class CodecHash$1 extends BasicInterface$1 {
 
   decode(buffer) {
     this.encoded = buffer;
-    const codec = varint__default["default"].decode(buffer);
+    const codec = varint.decode(buffer);
 
-    this.discoCodec = new PeernetCodec(codec, this.codecs);
+    this.discoCodec = new Codec$1(codec, this.codecs);
     // TODO: validate codec
-    buffer = buffer.slice(varint__default["default"].decode.bytes);
-    this.size = varint__default["default"].decode(buffer);
-    this.digest = buffer.slice(varint__default["default"].decode.bytes);
+    buffer = buffer.slice(varint.decode.bytes);
+    this.size = varint.decode(buffer);
+    this.digest = buffer.slice(varint.decode.bytes);
     if (this.digest.length !== this.size) {
       throw new Error(`hash length inconsistent: 0x${this.encoded.toString('hex')}`)
     }
@@ -436,129 +1476,180 @@ class CodecHash$1 extends BasicInterface$1 {
       digest: this.digest,
     }
   }
-}
+};
 
-class FormatInterface$1 extends BasicInterface$1 {
-
-  async protoEncode(data) {
-    // check schema
-    return new TextEncoder().encode(data)
-  }
-
-  async protoDecode(data) {
-    // check schema
-    return new TextDecoder().decode(data)
-  }
-
-  async init(buffer) {
-    if (buffer instanceof Uint8Array) await this.fromUint8Array(buffer);
-    else if (buffer instanceof ArrayBuffer) await this.fromArrayBuffer(buffer);
-    else if (buffer?.name === this.name) return buffer
-    else if (buffer instanceof String) {
-      if (this.isHex(buffer)) await this.fromHex(buffer);
-      else if (this.isBase32(buffer)) await this.fromBs32(buffer);
-      else if (this.isBase58(buffer)) await this.fromBs58(buffer);
-      else throw new Error(`unsupported string ${buffer}`)
-    } else {
-      await this.create(buffer);
-    }
-    return this
-  }
-
-  /**
-   * @param {Buffer|String|Object} buffer - data - The data needed to create the desired message
-   * @param {Object} proto - {encode, decode}
-   * @param {Object} options - {hashFormat, name}
-   */
-  constructor(buffer, proto, options = {}) {
-    super();
-    this.proto = proto;
-    this.hashFormat = options.hashFormat || 'bs32';
-    if (options.name) this.name = options.name;
-    return this.init(buffer)
-  }
-
-  /**
-   * @return {PeernetHash}
-   */
-  get peernetHash() {
-    return new CodecHash$1(this.decoded, {name: this.name})
-  }
-
-  /**
-   * @return {peernetHash}
-   */
-  get hash() {
-    const upper = this.hashFormat.charAt(0).toUpperCase();
-    const format = `${upper}${this.hashFormat.substring(1, this.hashFormat.length)}`;
-    return this.peernetHash[`to${format}`]()
-  }
-
-  /**
-   * @return {Object}
-   */
-  async decode() {
-    let encoded = this.encoded;
-    const discoCodec = new PeernetCodec(this.encoded);
-    encoded = encoded.slice(discoCodec.codecBuffer.length);
-    this.name = discoCodec.name;
-    this.decoded = await this.protoDecode(encoded);
-    try {
-      this.decoded = JSON.parse(this.decoded);
-    } catch {
-      
+var FormatInterface$1 = /** @class */ (function (_super) {
+    __extends(FormatInterface, _super);
+    /**
+     * @param {Buffer|String|Object} buffer - data - The data needed to create the desired message
+     * @param {Object} proto - {encode, decode}
+     * @param {Object} options - {hashFormat, name}
+     */
+    function FormatInterface(buffer, proto, options) {
+        if (options === void 0) { options = {}; }
+        var _this = _super.call(this) || this;
+        _this.proto = proto;
+        _this.hashFormat = options.hashFormat || 'bs32';
+        if (options.name)
+            _this.name = options.name;
+        return _this.init(buffer);
     }
-    return this.decoded
-  }
-
-  /**
-   * @return {Buffer}
-   */
-  async encode(decoded) {
-    let encoded;
-    if (!decoded) decoded = this.decoded;
-    const codec = new PeernetCodec(this.name);
-
-    if (decoded instanceof Uint8Array) encoded = decoded;
-    else encoded = await this.protoEncode(typeof decoded === 'object' ? JSON.stringify(decoded) : decoded);
-
-    const uint8Array = new Uint8Array(encoded.length + codec.codecBuffer.length);
-    uint8Array.set(codec.codecBuffer);
-    uint8Array.set(encoded, codec.codecBuffer.length);
-
-    this.encoded = uint8Array;
-    return this.encoded
-  }
-
-  hasCodec() {
-    if (!this.encoded) return false
-    const codec = new PeernetCodec(this.encoded);
-    if (codec.name) return true
-  }
-
-  fromUint8Array(buffer) {
-    this.encoded = buffer;
-    return this.hasCodec() ? this.decode() : this.create(
-      JSON.parse(new TextDecoder().decode(this.encoded))
-    )
-  }
-
-  fromArrayBuffer(buffer) {
-    this.encoded = new Uint8Array(buffer, buffer.byteOffset, buffer.byteLength);
-    return this.hasCodec() ? this.decode() : this.create(
-      JSON.parse(new TextDecoder().decode(this.encoded))
-    )
-  }
-}
+    FormatInterface.prototype.init = function (buffer) {
+        return __awaiter$1(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(buffer instanceof Uint8Array)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.fromUint8Array(buffer)];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 15];
+                    case 2:
+                        if (!(buffer instanceof ArrayBuffer)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.fromArrayBuffer(buffer)];
+                    case 3:
+                        _a.sent();
+                        return [3 /*break*/, 15];
+                    case 4:
+                        if (!((buffer === null || buffer === void 0 ? void 0 : buffer.name) === this.name)) return [3 /*break*/, 5];
+                        return [2 /*return*/, buffer];
+                    case 5:
+                        if (!(buffer instanceof String)) return [3 /*break*/, 13];
+                        if (!this.isHex(buffer)) return [3 /*break*/, 7];
+                        return [4 /*yield*/, this.fromHex(buffer)];
+                    case 6:
+                        _a.sent();
+                        return [3 /*break*/, 12];
+                    case 7:
+                        if (!this.isBase32(buffer)) return [3 /*break*/, 9];
+                        return [4 /*yield*/, this.fromBs32(buffer)];
+                    case 8:
+                        _a.sent();
+                        return [3 /*break*/, 12];
+                    case 9:
+                        if (!this.isBase58(buffer)) return [3 /*break*/, 11];
+                        return [4 /*yield*/, this.fromBs58(buffer)];
+                    case 10:
+                        _a.sent();
+                        return [3 /*break*/, 12];
+                    case 11: throw new Error("unsupported string ".concat(buffer));
+                    case 12: return [3 /*break*/, 15];
+                    case 13: return [4 /*yield*/, this.create(buffer)];
+                    case 14:
+                        _a.sent();
+                        _a.label = 15;
+                    case 15: return [2 /*return*/, this];
+                }
+            });
+        });
+    };
+    FormatInterface.prototype.hasCodec = function () {
+        if (!this.encoded)
+            return false;
+        var codec = new Codec$1(this.encoded);
+        if (codec.name)
+            return true;
+    };
+    FormatInterface.prototype.decode = function () {
+        return __awaiter$1(this, void 0, void 0, function () {
+            var encoded, codec, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        encoded = this.encoded;
+                        codec = new Codec$1(this.encoded);
+                        if (!codec.codecBuffer) return [3 /*break*/, 2];
+                        encoded = encoded.slice(codec.codecBuffer.length);
+                        this.name = codec.name;
+                        _a = this;
+                        return [4 /*yield*/, this.protoDecode(encoded)];
+                    case 1:
+                        _a.decoded = _b.sent();
+                        try {
+                            this.decoded = JSON.parse(this.decoded);
+                        }
+                        catch (_c) {
+                        }
+                        return [3 /*break*/, 3];
+                    case 2: throw new Error("no codec found");
+                    case 3: return [2 /*return*/, this.decoded];
+                }
+            });
+        });
+    };
+    FormatInterface.prototype.encode = function (decoded) {
+        return __awaiter$1(this, void 0, void 0, function () {
+            var encoded, codec, uint8Array;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!decoded)
+                            decoded = this.decoded;
+                        codec = new Codec$1(this.name);
+                        if (!(decoded instanceof Uint8Array)) return [3 /*break*/, 1];
+                        encoded = decoded;
+                        return [3 /*break*/, 3];
+                    case 1: return [4 /*yield*/, this.protoEncode(typeof decoded === 'object' ? JSON.stringify(decoded) : decoded)];
+                    case 2:
+                        encoded = _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        if (codec.codecBuffer) {
+                            uint8Array = new Uint8Array(encoded.length + codec.codecBuffer.length);
+                            uint8Array.set(codec.codecBuffer);
+                            uint8Array.set(encoded, codec.codecBuffer.length);
+                            this.encoded = uint8Array;
+                        }
+                        else {
+                            throw new Error("invalid codec");
+                        }
+                        return [2 /*return*/, this.encoded];
+                }
+            });
+        });
+    };
+    Object.defineProperty(FormatInterface.prototype, "peernetHash", {
+        /**
+         * @return {PeernetHash}
+         */
+        get: function () {
+            return new CodecHash$1(this.decoded, { name: this.name });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * @return {peernetHash}
+     */
+    FormatInterface.prototype.hash = function () {
+        return __awaiter$1(this, void 0, void 0, function () {
+            var upper, format;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        upper = this.hashFormat.charAt(0).toUpperCase();
+                        format = "".concat(upper).concat(this.hashFormat.substring(1, this.hashFormat.length));
+                        return [4 /*yield*/, this.peernetHash];
+                    case 1: return [2 /*return*/, (_a.sent())["to".concat(format)]()];
+                }
+            });
+        });
+    };
+    FormatInterface.prototype.fromUint8Array = function (buffer) {
+        this.encoded = buffer;
+        return this.hasCodec() ? this.decode() : this.create(JSON.parse(new TextDecoder().decode(this.encoded)));
+    };
+    FormatInterface.prototype.fromArrayBuffer = function (buffer) {
+        this.encoded = new Uint8Array(buffer, buffer.byteOffset, buffer.byteLength);
+        return this.hasCodec() ? this.decode() : this.create(JSON.parse(new TextDecoder().decode(this.encoded)));
+    };
+    return FormatInterface;
+}(BasicInterface$1));
+
+var BasicInterface = BasicInterface$1;
+var FormatInterface = FormatInterface$1;
+var CodecHash = CodecHash$1;
+var Codec = Codec$1;
+var Codecs = codecs;
 
-const BasicInterface = BasicInterface$1;
-const FormatInterface = FormatInterface$1;
-const CodecHash = CodecHash$1;
-const Codec = PeernetCodec;
-const Codecs = codecs;
-
-exports.BasicInterface = BasicInterface;
-exports.Codec = Codec;
-exports.CodecHash = CodecHash;
-exports.Codecs = Codecs;
-exports.FormatInterface = FormatInterface;
+export { BasicInterface, Codec, CodecHash, Codecs, FormatInterface };