@leofcoin/chain 1.4.35 → 1.4.36

package/exports/browser/contract-163f031f.js

@@ -0,0 +1,1859 @@
+// 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.
+const base = (ALPHABET) => {
+    if (ALPHABET.length >= 255) {
+        throw new TypeError('Alphabet too long');
+    }
+    const BASE_MAP = new Uint8Array(256);
+    for (let j = 0; j < BASE_MAP.length; j++) {
+        BASE_MAP[j] = 255;
+    }
+    for (let i = 0; i < ALPHABET.length; i++) {
+        const x = ALPHABET.charAt(i);
+        const xc = x.charCodeAt(0);
+        if (BASE_MAP[xc] !== 255) {
+            throw new TypeError(x + ' is ambiguous');
+        }
+        BASE_MAP[xc] = i;
+    }
+    const BASE = ALPHABET.length;
+    const LEADER = ALPHABET.charAt(0);
+    const FACTOR = Math.log(BASE) / Math.log(256); // log(BASE) / log(256), rounded up
+    const iFACTOR = Math.log(256) / Math.log(BASE); // log(256) / log(BASE), rounded up
+    const encode = (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.
+        let zeroes = 0;
+        let length = 0;
+        let pbegin = 0;
+        const pend = source.length;
+        while (pbegin !== pend && source[pbegin] === 0) {
+            pbegin++;
+            zeroes++;
+        }
+        // Allocate enough space in big-endian base58 representation.
+        const size = ((pend - pbegin) * iFACTOR + 1) >>> 0;
+        const b58 = new Uint8Array(size);
+        // Process the bytes.
+        while (pbegin !== pend) {
+            let carry = source[pbegin];
+            // Apply "b58 = b58 * 256 + ch".
+            let i = 0;
+            for (let 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.
+        let it2 = size - length;
+        while (it2 !== size && b58[it2] === 0) {
+            it2++;
+        }
+        // Translate the result into a string.
+        let str = LEADER.repeat(zeroes);
+        for (; it2 < size; ++it2) {
+            str += ALPHABET.charAt(b58[it2]);
+        }
+        return str;
+    };
+    const decodeUnsafe = (source) => {
+        if (typeof source !== 'string') {
+            throw new TypeError('Expected String');
+        }
+        if (source.length === 0) {
+            return new Uint8Array();
+        }
+        let psz = 0;
+        // Skip and count leading '1's.
+        let zeroes = 0;
+        let length = 0;
+        while (source[psz] === LEADER) {
+            zeroes++;
+            psz++;
+        }
+        // Allocate enough space in big-endian base256 representation.
+        const size = (((source.length - psz) * FACTOR) + 1) >>> 0; // log(58) / log(256), rounded up.
+        let b256 = new Uint8Array(size);
+        // Process the characters.
+        while (source[psz]) {
+            // Decode character
+            let carry = BASE_MAP[source.charCodeAt(psz)];
+            // Invalid character
+            if (carry === 255) {
+                return;
+            }
+            let i = 0;
+            for (let 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.
+        let it4 = size - length;
+        while (it4 !== size && b256[it4] === 0) {
+            it4++;
+        }
+        let vch = new Uint8Array(zeroes + (size - it4));
+        let j = zeroes;
+        while (it4 !== size) {
+            vch[j++] = b256[it4++];
+        }
+        return vch;
+    };
+    const decode = (string) => {
+        const buffer = decodeUnsafe(string);
+        if (buffer) {
+            return buffer;
+        }
+        throw new Error('Non-base' + BASE + ' character');
+    };
+    return {
+        encode,
+        decodeUnsafe,
+        decode
+    };
+};
+
+const ALPHABET$3 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
+const ALPHABET_HEX$1 = '0123456789ABCDEFGHIJKLMNOPQRSTUV';
+const base32 = base(ALPHABET$3);
+const base32Hex = base(ALPHABET_HEX$1);
+const decode$5 = base32.decode;
+const decodeHex$1 = base32Hex.decode;
+const encode$5 = base32.encode;
+const encodeHex$1 = base32Hex.encode;
+const isBase32 = (string, hex = false) => {
+    try {
+        if (hex)
+            decodeHex$1(string);
+        else
+            decode$5(string);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+};
+const isBase32Hex = (string) => {
+    return isBase32(string, true);
+};
+var index$7 = {
+    encode: encode$5,
+    decode: decode$5,
+    encodeHex: encodeHex$1,
+    decodeHex: decodeHex$1,
+    isBase32,
+    isBase32Hex
+};
+
+var ALPHABET$2 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+var ALPHABET_HEX = '0123456789ABCDEFGHJKLMNPQRSTUVabcdefghijklmnopqrstuv';
+var base58 = base(ALPHABET$2);
+var base58Hex = base(ALPHABET_HEX);
+var encode$4 = base58.encode;
+var decode$4 = base58.decode;
+var encodeHex = base58Hex.encode;
+var decodeHex = base58Hex.decode;
+var isBase58 = function (string) {
+    try {
+        decode$4(string);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+};
+var isBase58Hex = function (string) {
+    try {
+        decodeHex(string);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+};
+var whatType = function (string) {
+    try {
+        decode$4(string);
+        return 'base58';
+    }
+    catch (e) {
+        try {
+            decodeHex(string);
+            return 'base58Hex';
+        }
+        catch (_a) {
+            return;
+        }
+    }
+};
+var base58$1 = { encode: encode$4, decode: decode$4, isBase58: isBase58, isBase58Hex: isBase58Hex, encodeHex: encodeHex, decodeHex: decodeHex, whatType: whatType };
+
+const MSB$1 = 0x80;
+const REST$1 = 0x7F;
+const MSBALL = ~REST$1;
+const INT = Math.pow(2, 31);
+const encode$3 = (num, out, offset) => {
+    if (Number.MAX_SAFE_INTEGER && num > Number.MAX_SAFE_INTEGER) {
+        encode$3.bytes = 0;
+        throw new RangeError('Could not encode varint');
+    }
+    out = out || [];
+    offset = offset || 0;
+    const 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$3.bytes = offset - oldOffset + 1;
+    return out;
+};
+
+const MSB = 0x80;
+const REST = 0x7F;
+const decode$3 = (buf, offset) => {
+    offset = offset || 0;
+    const l = buf.length;
+    let counter = offset;
+    let result = 0;
+    let shift = 0;
+    let b;
+    do {
+        if (counter >= l || shift > 49) {
+            decode$3.bytes = 0;
+            throw new RangeError('Could not decode varint');
+        }
+        b = buf[counter++];
+        result += shift < 28
+            ? (b & REST) << shift
+            : (b & REST) * Math.pow(2, shift);
+        shift += 7;
+    } while (b >= MSB);
+    decode$3.bytes = counter - offset;
+    return result;
+};
+
+const N1 = Math.pow(2, 7);
+const N2 = Math.pow(2, 14);
+const N3 = Math.pow(2, 21);
+const N4 = Math.pow(2, 28);
+const N5 = Math.pow(2, 35);
+const N6 = Math.pow(2, 42);
+const N7 = Math.pow(2, 49);
+const N8 = Math.pow(2, 56);
+const N9 = Math.pow(2, 63);
+var encodingLength = (value) => (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 index$6 = {
+    encode: encode$3,
+    decode: decode$3,
+    encodingLength
+};
+
+var index$5 = (input, prefix) => {
+    const encodedArray = [];
+    const length = input.reduce((total, current) => {
+        const encoded = index$6.encode(current.length);
+        encodedArray.push(encoded);
+        total += current.length + encoded.length;
+        return total;
+    }, 0);
+    const typedArray = new Uint8Array(prefix ? prefix.length + length : length);
+    let currentIndex = 0;
+    let index = 0;
+    if (prefix) {
+        typedArray.set(prefix);
+        currentIndex += prefix.length;
+    }
+    for (const source of input) {
+        typedArray.set(encodedArray[index], currentIndex);
+        currentIndex += encodedArray[index].length;
+        typedArray.set(source, currentIndex);
+        currentIndex += source.length;
+        index += 1;
+    }
+    return typedArray;
+};
+
+var index$4 = (typedArray, prefix) => {
+    const set = [];
+    if (prefix)
+        typedArray = typedArray.subarray(prefix.length);
+    const varintAndSub = (typedArray) => {
+        const length = index$6.decode(typedArray);
+        // remove length
+        typedArray = typedArray.subarray(index$6.decode.bytes);
+        // push value
+        set.push(typedArray.subarray(0, length));
+        // remove value
+        typedArray = typedArray.subarray(length);
+        if (typedArray.length !== 0)
+            return varintAndSub(typedArray);
+        return set;
+    };
+    return varintAndSub(typedArray);
+};
+
+const ALPHABET$1 = '0123456789ABCDEF';
+const base16 = base(ALPHABET$1);
+const decode$2 = base16.decode;
+const encode$2 = base16.encode;
+const isBase16 = (string) => {
+    try {
+        decode$2(string);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+};
+var index$3 = {
+    encode: encode$2,
+    decode: decode$2,
+    isBase16
+};
+
+const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+const base64 = base(ALPHABET);
+const decode$1 = base64.decode;
+const encode$1 = base64.encode;
+const isBase64 = (string) => {
+    try {
+        decode$1(string);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+};
+var index$2 = {
+    encode: encode$1,
+    decode: decode$1,
+    isBase64
+};
+
+const isTypedArrayCompatible = (possibleUint8Array) => {
+    if (typeof possibleUint8Array === 'string') {
+        possibleUint8Array = possibleUint8Array.split(',').map(number => Number(number));
+        for (const number of possibleUint8Array) {
+            if (isNaN(number))
+                return false;
+        }
+    }
+    for (const number of possibleUint8Array) {
+        if (isNaN(number))
+            return false;
+    }
+    return true;
+};
+/**
+ * Returns a String as Uint8Array
+ * @param string string to encode to Uint8Array
+ * @returns Uint8Array
+ */
+const fromString$1 = (string) => new TextEncoder().encode(string);
+/**
+ * Returns a Uint8Array as String
+ * @param uint8Array Uint8Array to encode to String
+ * @returns String
+ */
+const toString$1 = (uint8Array) => new TextDecoder().decode(uint8Array);
+/**
+ * Returns a String as Uint8Array
+ * @param string string to encode to Uint8Array
+ * @returns Uint8Array
+ */
+const fromUintArrayString = (string) => Uint8Array.from(string.split(',').map(string => Number(string)));
+/**
+ * Returns a Uint8Array as String
+ * @param uint8Array Uint8Array to encode to String
+ * @returns String
+ */
+const toUintArrayString = (uint8Array) => uint8Array.toString();
+/**
+ * hexString -> uint8Array
+ * @param string hex encoded string
+ * @returns UintArray
+ */
+const fromHex = (string) => Uint8Array.from(string.match(/.{1,2}/g).map((byte) => parseInt(byte, 16)));
+/**
+ * uint8Array -> hexString
+ * @param bytes number[]
+ * @returns hexString
+ */
+const toHex = (bytes) => bytes.reduce((string, byte) => string + byte.toString(16).padStart(2, '0'), '');
+/**
+ * number[] -> Uint8Array
+ * @param array number[]
+ * @returns Uint8Array
+ */
+const fromArrayLike = (array) => Uint8Array.from(array);
+/**
+ * Uint8Array -> number[]
+ * @param uint8Array Uint8Array
+ * @returns Uint8Array
+ */
+const toArrayLike = (uint8Array) => [...uint8Array.values()];
+const toBase64 = (uint8Array) => index$2.encode(uint8Array);
+const fromBase64 = (string) => index$2.decode(string);
+const toBase58 = (uint8Array) => base58$1.encode(uint8Array);
+const fromBase58 = (string) => base58$1.decode(string);
+const toBase32 = (uint8Array) => index$7.encode(uint8Array);
+const fromBase32 = (string) => index$7.decode(string);
+const toBase16 = (uint8Array) => index$3.encode(uint8Array);
+const fromBase16 = (string) => index$3.decode(string);
+let FormatInterface$2 = class FormatInterface {
+    encoded;
+    constructor(input) {
+        if (input) {
+            if (index$3.isBase16(input))
+                this.encoded = this.fromBase16(input);
+            else if (index$7.isBase32(input))
+                this.encoded = this.fromBase32(input);
+            else if (base58$1.isBase58(input))
+                this.encoded = this.fromBase58(input);
+            else if (index$2.isBase64(input))
+                this.encoded = this.fromBase64(input);
+            else if (typeof input === 'string') {
+                let isCompatible = isTypedArrayCompatible(input);
+                if (isCompatible)
+                    this.encoded = fromUintArrayString(input);
+                else
+                    this.encoded = this.fromString(input); // normal string
+            }
+            else if (typeof input === 'object')
+                this.encoded = this.fromObject(input);
+            else if (input instanceof Uint8Array)
+                this.encoded = input;
+            else if (Array.isArray(input) && isTypedArrayCompatible(input))
+                this.encoded = this.fromArrayLike(input);
+        }
+    }
+    /**
+   * Returns a String as Uint8Array
+   * @param string string to encode to Uint8Array
+   * @returns Uint8Array
+   */
+    fromString(string) {
+        return new TextEncoder().encode(string);
+    }
+    /**
+     * Returns a Uint8Array as String
+     * @param uint8Array Uint8Array to encode to String
+     * @returns String
+     */
+    toString(uint8Array) {
+        return new TextDecoder().decode(uint8Array);
+    }
+    /**
+     * Returns a String as Uint8Array
+     * @param string string to encode to Uint8Array
+     * @returns Uint8Array
+     */
+    fromUintArrayString(string) {
+        return Uint8Array.from(string.split(',').map(string => Number(string)));
+    }
+    /**
+     * Returns a Uint8Array as String
+     * @param uint8Array Uint8Array to encode to String
+     * @returns String
+     */
+    toUintArrayString(uint8Array) {
+        return uint8Array.toString();
+    }
+    /**
+     * hexString -> uint8Array
+     * @param string hex encoded string
+     * @returns UintArray
+     */
+    fromHex(string) {
+        return Uint8Array.from(string.match(/.{1,2}/g).map((byte) => parseInt(byte, 16)));
+    }
+    /**
+     * uint8Array -> hexString
+     * @param bytes number[]
+     * @returns hexString
+     */
+    toHex(bytes) {
+        return bytes.reduce((string, byte) => string + byte.toString(16).padStart(2, '0'), '');
+    }
+    /**
+     * number[] -> Uint8Array
+     * @param array number[]
+     * @returns Uint8Array
+     */
+    fromArrayLike(array) {
+        return Uint8Array.from(array);
+    }
+    /**
+     * Uint8Array -> number[]
+     * @param uint8Array Uint8Array
+     * @returns Uint8Array
+     */
+    toArrayLike(uint8Array) {
+        return [...uint8Array.values()];
+    }
+    fromObject(object) {
+        return new TextEncoder().encode(JSON.stringify(object));
+    }
+    toObject(uint8Array) {
+        return JSON.parse(new TextDecoder().decode(uint8Array));
+    }
+    toBase64(uint8Array) {
+        return index$2.encode(uint8Array);
+    }
+    fromBase64(string) {
+        return index$2.decode(string);
+    }
+    toBase58(uint8Array) {
+        return base58$1.encode(uint8Array);
+    }
+    fromBase58(string) {
+        return base58$1.decode(string);
+    }
+    toBase32(uint8Array) {
+        return index$7.encode(uint8Array);
+    }
+    fromBase32(string) {
+        return index$7.decode(string);
+    }
+    toBase16(uint8Array) {
+        return index$3.encode(uint8Array);
+    }
+    fromBase16(string) {
+        return index$3.decode(string);
+    }
+};
+var index$1 = {
+    fromString: fromString$1,
+    toString: toString$1,
+    fromHex,
+    toHex,
+    fromArrayLike,
+    toArrayLike,
+    fromUintArrayString,
+    toUintArrayString,
+    toBase64,
+    fromBase64,
+    toBase58,
+    fromBase58,
+    toBase32,
+    fromBase32,
+    toBase16,
+    fromBase16,
+    FormatInterface: FormatInterface$2
+};
+
+const { fromString, toString } = index$1;
+const isJson = (type) => type === 'object' || 'array';
+const isString = (type) => type === 'string';
+const isNumber = (type) => type === 'number';
+const isBoolean = (type) => type === 'boolean';
+const isUint8Array = (type) => type === 'uint8Array';
+const tokenize = (key, value) => {
+    const optional = key.endsWith('?');
+    let type = value;
+    type = Array.isArray(type) ? 'array' : typeof type;
+    if (value instanceof Uint8Array)
+        type = 'uint8Array';
+    const parts = key.split('?');
+    const minimumLength = parts[2]?.includes('min') ? parts[2].split['min:'][1] : 0;
+    return { type, optional, key: parts[0], minimumLength };
+};
+const toType = (data) => {
+    // always return uint8Arrays as they are
+    if (data instanceof Uint8Array)
+        return data;
+    // returns the ArrayBuffer as a UintArray
+    if (data instanceof ArrayBuffer)
+        return new Uint8Array(data);
+    // returns the string as a UintArray
+    if (typeof data === 'string')
+        return new TextEncoder().encode(data);
+    // returns the object as a UintArray
+    if (typeof data === 'object')
+        return new TextEncoder().encode(JSON.stringify(data));
+    // returns the number as a UintArray
+    if (typeof data === 'number' || typeof data === 'boolean')
+        return new TextEncoder().encode(data.toString());
+    throw new Error(`unsuported type ${typeof data || data}`);
+};
+const encode = (proto, input) => {
+    const keys = Object.keys(proto);
+    const values = Object.values(proto);
+    const set = [];
+    for (let i = 0; i < keys.length; i++) {
+        const token = tokenize(keys[i], values[i]);
+        const data = input[token.key];
+        if (!token.optional && data === undefined)
+            throw new Error(`missing required property: ${token.key}`);
+        if (token.type === 'array' && token.minimumLength > data.length || token.type === 'object' && token.minimumLength > Object.keys(data).length)
+            throw new Error(`minimumLength for ${token.key} is set to ${token.minimumLength} but got ${data.length}`);
+        // always push data to the set.
+        // when data is undefined push the default value of the proto
+        set.push(toType(data || values[i]));
+    }
+    return index$5(set);
+};
+const decode = (proto, uint8Array) => {
+    let deconcated = index$4(uint8Array);
+    const output = {};
+    const keys = Object.keys(proto);
+    const values = Object.values(proto);
+    if (keys.length !== deconcated.length)
+        console.warn(`length mismatch: expected  ${keys.length} got ${uint8Array.length}`);
+    for (let i = 0; i < keys.length; i++) {
+        const token = tokenize(keys[i], values[i]);
+        if (isUint8Array(token.type))
+            output[token.key] = deconcated[i];
+        else if (isString(token.type))
+            output[token.key] = toString(deconcated[i]);
+        else if (isBoolean(token.type))
+            output[token.key] = Boolean(new TextDecoder().decode(deconcated[i]));
+        else if (isNumber(token.type))
+            output[token.key] = Number(new TextDecoder().decode(deconcated[i]));
+        else if (isJson(token.type))
+            output[token.key] = JSON.parse(new TextDecoder().decode(deconcated[i]));
+        if (token.optional) {
+            if (!output[token.key] || output[token.key].length === 0)
+                delete output[token.key];
+        }
+        if (!token.optional && output[token.key] === undefined)
+            throw new Error(`missing required property: ${token.key}`);
+    }
+    return output;
+};
+var index = {
+    encode,
+    decode
+};
+
+/*!
+ * hash-wasm (https://www.npmjs.com/package/hash-wasm)
+ * (c) Dani Biro
+ * @license MIT
+ */
+
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+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();
+
+const blockchainCodecs = [
+    {
+        name: 'leofcoin-block',
+        codec: '0x6c62',
+        hashAlg: 'dbl-keccak-512',
+    },
+    {
+        name: 'leofcoin-tx',
+        codec: '0x6c74',
+        hashAlg: 'dbl-keccak-512',
+    },
+    {
+        name: 'leofcoin-itx',
+        codec: '0x6c69',
+        hashAlg: 'keccak-512',
+    },
+    {
+        name: 'leofcoin-pr',
+        codec: '0x6c70',
+        hashAlg: 'keccak-256',
+    },
+    {
+        name: 'contract-message',
+        codec: '0x63636d',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'transaction-message',
+        codec: '0x746d',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'block-message',
+        codec: '0x626d',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'bw-message',
+        codec: '0x62776d',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'bw-request-message',
+        codec: '0x6277726d',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'validator-message',
+        codec: '0x766d',
+        hashAlg: 'keccak-256'
+    }
+];
+
+const internalCodecs = [
+    {
+        name: 'disco-hash',
+        codec: '0x30',
+        hashAlg: 'dbl-keccak-256',
+    },
+    {
+        name: 'peernet-peer-response',
+        codec: '0x707072',
+        hashAlg: 'keccak-256',
+    },
+    {
+        name: 'peernet-peer',
+        codec: '0x7070',
+        hashAlg: 'keccak-256',
+    },
+    {
+        name: 'peernet-dht',
+        codec: '0x706468',
+        hashAlg: 'keccak-256',
+    },
+    {
+        name: 'peernet-dht-response',
+        codec: '0x706472',
+        hashAlg: 'keccak-256',
+    },
+    {
+        name: 'peernet-data',
+        codec: '0x706461',
+        hashAlg: 'keccak-256',
+    },
+    {
+        name: 'peernet-data-response',
+        codec: '0x70646172',
+        hashAlg: 'keccak-256',
+    },
+    {
+        name: 'peernet-message',
+        codec: '0x706d65',
+        hashAlg: 'keccak-256',
+    },
+    {
+        name: 'peernet-ps',
+        codec: '707073',
+        hashAlg: 'keccak-256',
+    },
+    {
+        name: 'peernet-response',
+        codec: '0x7072',
+        hashAlg: 'keccak-256',
+    },
+    {
+        name: 'peernet-request',
+        codec: '0x707271',
+        hashAlg: 'keccak-256',
+    },
+    {
+        name: 'peernet-file',
+        codec: '0x7066',
+        hashAlg: 'keccak-256',
+    },
+    {
+        name: 'peernet-file-response',
+        codec: '0x706672',
+        hashAlg: 'keccak-256',
+    }
+];
+
+const codecs = [
+    ...internalCodecs,
+    ...blockchainCodecs,
+    {
+        name: 'chat-message',
+        codec: '0x70636d',
+        hashAlg: 'dbl-keccak-256',
+    }
+];
+
+globalThis.peernetCodecs = globalThis.peernetCodecs || {};
+const addCodec = (codecInput) => {
+    let { hashAlg, codec, name } = codecInput;
+    if (!globalThis.peernetCodecs[name])
+        globalThis.peernetCodecs[name] = {
+            hashAlg,
+            codec: typeof codec === 'string' ? parseInt(codec, 16) : codec
+        };
+};
+const getCodec = (name) => {
+    if (typeof name === 'number')
+        return name;
+    return getCodecByName(name).codec;
+};
+const getCodecName = (codec) => {
+    return Object.keys(globalThis.peernetCodecs).reduce((p, c) => {
+        const item = globalThis.peernetCodecs[c];
+        if (item.codec === codec)
+            return c;
+        else
+            return p;
+    }, undefined);
+};
+const getCodecByName = (name) => globalThis.peernetCodecs[name];
+const getHashAlg = (name) => {
+    if (typeof name === 'number')
+        return getCodecByName(getCodecName(name)).hashAlg;
+    return getCodecByName(name).hashAlg;
+};
+const isCodec = (codec) => {
+    if (codec.codec !== undefined && codec.hashAlg)
+        return true;
+    return false;
+};
+const validateCodec = (codec) => {
+    if (codec.codec === undefined ||
+        codec.hashAlg === undefined ||
+        codec.name === undefined)
+        throw new Error(`invalid codecInput: ${codec}`);
+};
+for (const codec of codecs) {
+    addCodec(codec);
+}
+var utils = {
+    isCodec,
+    addCodec,
+    getCodec,
+    getHashAlg,
+    getCodecName,
+    validateCodec,
+    codecs: globalThis.peernetCodecs
+};
+
+/**
+ * @param {string}
+ */
+var isHex = (function (string) { return /^[A-F0-9]+$/i.test(string); });
+
+let BasicInterface$1 = class BasicInterface {
+    encoded;
+    decoded;
+    keys;
+    name;
+    #proto;
+    set proto(value) {
+        this.#proto = value;
+        this.keys = Object.keys(value);
+    }
+    get proto() {
+        return this.#proto;
+    }
+    decode(encoded) {
+        encoded = encoded || this.encoded;
+        return new Object();
+    }
+    encode(decoded) {
+        decoded = decoded || this.decoded;
+        return new Uint8Array();
+    }
+    // get Codec(): Codec {}
+    protoEncode(data) {
+        // check schema
+        return index.encode(this.proto, data);
+    }
+    protoDecode(data) {
+        // check schema
+        return index.decode(this.proto, data);
+    }
+    isHex(string) {
+        return isHex(string);
+    }
+    isBase32(string) {
+        return index$7.isBase32(string);
+    }
+    isBase58(string) {
+        return base58$1.isBase58(string);
+    }
+    fromBs32(encoded) {
+        return this.decode(index$7.decode(encoded));
+    }
+    fromBs58(encoded) {
+        return this.decode(fromBase58(encoded));
+    }
+    async toArray() {
+        const array = [];
+        for await (const value of this.encoded.values()) {
+            array.push(value);
+        }
+        return array;
+    }
+    fromString(string) {
+        const array = string.split(',');
+        const arrayLike = array.map(string => Number(string));
+        return this.decode(Uint8Array.from(arrayLike));
+    }
+    fromHex(string) {
+        return this.decode(fromHex(string));
+    }
+    fromArray(array) {
+        return this.decode(Uint8Array.from([...array]));
+    }
+    fromEncoded(encoded) {
+        return this.decode(encoded);
+    }
+    toString() {
+        if (!this.encoded)
+            this.encode();
+        return this.encoded.toString();
+    }
+    toHex() {
+        if (!this.encoded)
+            this.encode();
+        return toHex(this.encoded.toString().split(',').map(number => Number(number)));
+    }
+    /**
+     * @return {String} encoded
+     */
+    toBs32() {
+        if (!this.encoded)
+            this.encode();
+        return toBase32(this.encoded);
+    }
+    /**
+     * @return {String} encoded
+     */
+    toBs58() {
+        if (!this.encoded)
+            this.encode();
+        return toBase58(this.encoded);
+    }
+};
+
+let Codec$1 = class Codec extends BasicInterface$1 {
+    codecBuffer;
+    codec;
+    hashAlg;
+    constructor(buffer) {
+        super();
+        if (buffer) {
+            if (buffer instanceof Uint8Array) {
+                const codec = index$6.decode(buffer);
+                const name = this.getCodecName(codec);
+                if (name) {
+                    this.name = name;
+                    this.encoded = buffer;
+                    this.decode(buffer);
+                }
+                else {
+                    this.encode(Number(new TextDecoder().decode(buffer)));
+                }
+            }
+            else if (buffer instanceof ArrayBuffer) {
+                const codec = index$6.decode(new Uint8Array(buffer));
+                const name = this.getCodecName(codec);
+                if (name) {
+                    this.name = name;
+                    this.decode(buffer);
+                }
+                else {
+                    this.encode(Number(new TextDecoder().decode(new Uint8Array(buffer))));
+                }
+            }
+            else if (typeof buffer === 'string') {
+                if (utils.getCodec(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
+                    this.fromString(buffer);
+            }
+            if (!isNaN(buffer))
+                if (utils.getCodec(buffer))
+                    this.fromCodec(buffer);
+        }
+    }
+    fromEncoded(encoded) {
+        const codec = index$6.decode(encoded);
+        const name = this.getCodecName(codec);
+        this.name = name;
+        this.encoded = encoded;
+        return this.decode(encoded);
+    }
+    getCodec(name) {
+        return utils.getCodec(name);
+    }
+    getCodecName(codec) {
+        return utils.getCodecName(codec);
+    }
+    getHashAlg(name) {
+        return utils.getHashAlg(name);
+    }
+    fromCodec(codec) {
+        this.name = this.getCodecName(codec);
+        this.hashAlg = this.getHashAlg(this.name);
+        this.codec = this.getCodec(this.name);
+        this.codecBuffer = index$6.encode(this.codec);
+    }
+    fromName(name) {
+        const codec = this.getCodec(name);
+        this.name = name;
+        this.codec = codec;
+        this.hashAlg = this.getHashAlg(name);
+        this.codecBuffer = index$6.encode(this.codec);
+    }
+    decode(encoded) {
+        encoded = encoded || this.encoded;
+        const codec = index$6.decode(encoded);
+        this.fromCodec(codec);
+        return this.decoded;
+    }
+    encode(codec) {
+        codec = codec || this.codec;
+        this.encoded = index$6.encode(codec);
+        return this.encoded;
+    }
+};
+
+let CodecHash$1 = class CodecHash extends BasicInterface$1 {
+    codec;
+    codecs;
+    digest;
+    size;
+    constructor(buffer, options) {
+        super();
+        if (options.name)
+            this.name = options.name;
+        else
+            this.name = 'disco-hash';
+        if (options.codecs)
+            this.codecs = options.codecs;
+        return this.init(buffer);
+    }
+    async init(uint8Array) {
+        if (uint8Array) {
+            if (uint8Array instanceof Uint8Array) {
+                this.codec = new Codec$1(uint8Array);
+                const name = this.codec.name;
+                if (name) {
+                    this.name = name;
+                    this.decode(uint8Array);
+                }
+                else {
+                    await this.encode(uint8Array);
+                }
+            }
+            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.codec.codecBuffer.length);
+        uint8Array.set(length);
+        uint8Array.set(this.codec.codecBuffer, length.length);
+        return uint8Array;
+    }
+    get length() {
+        return index$6.encode(this.size);
+    }
+    get buffer() {
+        return this.encoded;
+    }
+    get hash() {
+        return this.encoded;
+    }
+    fromJSON(json) {
+        return this.encode(new TextEncoder().encode(JSON.stringify(json)));
+    }
+    async encode(buffer, name) {
+        if (!this.name && name)
+            this.name = name;
+        if (!buffer)
+            buffer = this.buffer;
+        this.codec = new Codec$1(this.name);
+        this.codec.fromName(this.name);
+        let hashAlg = this.codec.hashAlg;
+        const hashVariant = Number(hashAlg.split('-')[hashAlg.split('-').length - 1]);
+        if (hashAlg.includes('dbl')) {
+            hashAlg = hashAlg.replace('dbl-', '');
+            const hasher = await createKeccak(hashVariant);
+            await hasher.init();
+            hasher.update(buffer);
+            buffer = hasher.digest('binary');
+        }
+        const hasher = await createKeccak(hashVariant);
+        await hasher.init();
+        hasher.update(buffer);
+        this.digest = hasher.digest('binary');
+        this.size = this.digest.length;
+        const uint8Array = new Uint8Array(this.digest.length + this.prefix.length);
+        uint8Array.set(this.prefix);
+        uint8Array.set(this.digest, this.prefix.length);
+        this.encoded = uint8Array;
+        return this.encoded;
+    }
+    async validate(buffer) {
+        if (Buffer.isBuffer(buffer)) {
+            const codec = index$6.decode(buffer);
+            if (this.codecs[codec]) {
+                this.decode(buffer);
+            }
+            else {
+                await this.encode(buffer);
+            }
+        }
+        if (typeof buffer === 'string') {
+            if (this.isHex(buffer))
+                this.fromHex(buffer);
+            if (this.isBase32(buffer))
+                this.fromBs32(buffer);
+        }
+        if (typeof buffer === 'object')
+            this.fromJSON(buffer);
+    }
+    decode(buffer) {
+        this.encoded = buffer;
+        const codec = index$6.decode(buffer);
+        this.codec = new Codec$1(codec);
+        // TODO: validate codec
+        buffer = buffer.slice(index$6.decode.bytes);
+        this.size = index$6.decode(buffer);
+        this.digest = buffer.slice(index$6.decode.bytes);
+        if (this.digest.length !== this.size) {
+            throw new Error(`hash length inconsistent: ${this.encoded.toString()}`);
+        }
+        // const codec = new Codec(codec, this.codecs)
+        this.name = this.codec.name;
+        this.size = this.digest.length;
+        return {
+            codec: this.codec,
+            name: this.name,
+            size: this.size,
+            length: this.length,
+            digest: this.digest,
+        };
+    }
+};
+
+let FormatInterface$1 = class FormatInterface extends BasicInterface$1 {
+    hashFormat;
+    init(buffer) {
+        if (buffer instanceof Uint8Array)
+            this.fromUint8Array(buffer);
+        else if (buffer instanceof ArrayBuffer)
+            this.fromArrayBuffer(buffer);
+        else if (buffer instanceof FormatInterface$1 && buffer?.name === this.name)
+            return buffer;
+        else if (typeof buffer === 'string') {
+            if (this.isHex(buffer))
+                this.fromHex(buffer);
+            else if (this.isBase58(buffer))
+                this.fromBs58(buffer);
+            else if (this.isBase32(buffer))
+                this.fromBs32(buffer);
+            else
+                this.fromString(buffer);
+        }
+        else {
+            this.create(buffer);
+        }
+        return this;
+    }
+    hasCodec() {
+        if (!this.encoded)
+            return false;
+        const codec = new Codec$1(this.encoded);
+        if (codec.name)
+            return true;
+    }
+    decode(encoded) {
+        encoded = encoded || this.encoded;
+        const codec = new Codec$1(this.encoded);
+        if (codec.codecBuffer) {
+            encoded = encoded.slice(codec.codecBuffer.length);
+            this.name = codec.name;
+            this.decoded = this.protoDecode(encoded);
+            // try {
+            //   this.decoded = JSON.parse(this.decoded)
+            // } catch {
+            // }
+        }
+        else {
+            throw new Error(`no codec found`);
+        }
+        return this.decoded;
+    }
+    encode(decoded) {
+        let encoded;
+        if (!decoded)
+            decoded = this.decoded;
+        const codec = new Codec$1(this.name);
+        if (decoded instanceof Uint8Array)
+            encoded = decoded;
+        else
+            encoded = this.protoEncode(decoded);
+        if (codec.codecBuffer) {
+            const 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 this.encoded;
+    }
+    /**
+     * @param {Buffer|String|Object} buffer - data - The data needed to create the desired message
+     * @param {Object} proto - {protoObject}
+     * @param {Object} options - {hashFormat, name}
+     */
+    constructor(buffer, proto, options) {
+        super();
+        this.proto = proto;
+        this.hashFormat = options?.hashFormat ? options.hashFormat : 'bs32';
+        if (options?.name)
+            this.name = options.name;
+        this.init(buffer);
+    }
+    /**
+     * @return {PeernetHash}
+     */
+    get peernetHash() {
+        return new CodecHash$1(this.decoded, { name: this.name });
+    }
+    /**
+     * @return {peernetHash}
+     */
+    async hash() {
+        const upper = this.hashFormat.charAt(0).toUpperCase();
+        const format = `${upper}${this.hashFormat.substring(1, this.hashFormat.length)}`;
+        return (await this.peernetHash)[`to${format}`]();
+    }
+    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)));
+    }
+    /**
+     * @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: (value) => data[key],
+                        get: () => data[key]
+                    }
+                });
+            }
+            this.decoded = decoded;
+            return this.encode(decoded);
+        }
+    }
+};
+const FormatInterface = FormatInterface$1;
+const CodecHash = CodecHash$1;
+
+var proto$5 = {
+  timestamp: Number(),
+  from: String(),
+  to: String(),
+  nonce: Number(),
+  method: String(),
+  params: Array(),
+  signature: new Uint8Array()
+};
+
+class TransactionMessage extends FormatInterface {
+    get messageName() {
+        return 'TransactionMessage';
+    }
+    constructor(buffer) {
+        const name = 'transaction-message';
+        super(buffer, proto$5, { name });
+    }
+}
+
+var proto$4 = {
+  address: String(),
+  reward: Number()
+};
+
+class ValidatorMessage extends FormatInterface {
+    get messageName() {
+        return 'ValidatorMessage';
+    }
+    constructor(buffer) {
+        const name = 'validator-message';
+        super(buffer, proto$4, { name });
+    }
+}
+
+var proto$3 = {
+  index: Number(),
+  previousHash: String(),
+  timestamp: Number(),
+  reward: Number(),
+  fees: Number(),
+  transactions: new Uint8Array(),
+  validators: new Uint8Array()
+};
+
+class BlockMessage extends FormatInterface {
+    get messageName() {
+        return 'BlockMessage';
+    }
+    constructor(buffer) {
+        const name = 'block-message';
+        super(buffer, proto$3, { name });
+    }
+    encode() {
+        const decoded = this.decoded;
+        const validators = [];
+        const transactions = [];
+        for (const validator of decoded.validators) {
+            if (validator instanceof ValidatorMessage)
+                validators.push(validator.encoded);
+            else
+                validators.push(new ValidatorMessage(validator).encoded);
+        }
+        for (const transaction of decoded.transactions) {
+            if (transaction instanceof TransactionMessage)
+                transactions.push(transaction.encoded);
+            else
+                transactions.push(new TransactionMessage(transaction).encoded);
+        }
+        return super.encode({
+            ...decoded,
+            validators: index$5(validators),
+            transactions: index$5(transactions)
+        });
+    }
+    decode() {
+        super.decode();
+        this.decoded.transactions = index$4(this.decoded.transactions).map(transaction => new TransactionMessage(transaction).decoded);
+        this.decoded.validators = index$4(this.decoded.validators).map(validator => new ValidatorMessage(validator).decoded);
+        return this.decoded;
+    }
+}
+
+var proto$2 = {
+  up: Number(),
+  down: Number()
+};
+
+class BWMessage extends FormatInterface {
+    get messageName() {
+        return 'BWMessage';
+    }
+    constructor(buffer) {
+        const name = 'bw-message';
+        super(buffer, proto$2, { name });
+    }
+}
+
+var proto$1 = {
+};
+
+class BWRequestMessage extends FormatInterface {
+    get messageName() {
+        return 'BWRequestMessage';
+    }
+    constructor(buffer) {
+        const name = 'bw-request-message';
+        super(buffer, proto$1, { name });
+    }
+}
+
+var proto = {
+  creator: String(),
+  contract: new Uint8Array(),
+  constructorParameters: Array()
+};
+
+class ContractMessage extends FormatInterface {
+    get messageName() {
+        return 'ContractMessage';
+    }
+    constructor(buffer) {
+        super(buffer, proto, { name: 'contract-message' });
+    }
+}
+
+export { BlockMessage as B, ContractMessage as C, TransactionMessage as T, ValidatorMessage as V, CodecHash as a, BWMessage as b, BWRequestMessage as c };