@leofcoin/peernet 0.18.7 → 1.0.0

package/exports/browser/{index-f3625c4a.js → peernet-1908438f.js}

@@ -1,5 +1,2379 @@
-import { b as base58$1, i as index$1, a as index$2, c as index$3, d as index$4, e as createRIPEMD160, f as createHMAC, g as createSHA512, h as createKeccak } from './peernet-29c659a0.js';
-import './value-40634404.js';
+import { K as KeyValue } from './value-157ab062.js';
+
+if (!globalThis.DEBUG) {
+  if (globalThis.localStorage) globalThis.DEBUG = Boolean(globalThis.localStorage.getItem('DEBUG') === 'true');
+}
+
+globalThis.debug = text => {
+  if (globalThis.DEBUG) console.log('\x1b[34m\x1b[1m%s', text, '\x1b[0m'); // bright blue
+};
+
+class LittlePubSub {
+    subscribers = {};
+    verbose;
+    constructor(verbose = false) {
+        this.verbose = verbose;
+    }
+    #handleContext(handler, context) {
+        if (typeof context === 'undefined') {
+            context = handler;
+        }
+        return context;
+    }
+    hasSubscribers(event) {
+        return this.subscribers[event] ? true : false;
+    }
+    subscribe(event, handler, context) {
+        if (!this.hasSubscribers(event))
+            this.subscribers[event] = { handlers: [], value: undefined };
+        context = this.#handleContext(handler, context);
+        this.subscribers[event].handlers.push(handler.bind(context));
+    }
+    unsubscribe(event, handler, context) {
+        if (!this.hasSubscribers(event))
+            return;
+        context = this.#handleContext(handler, context);
+        const index = this.subscribers[event].handlers.indexOf(handler.bind(context));
+        this.subscribers[event].handlers.splice(index);
+        if (this.subscribers[event].handlers.length === 0)
+            delete this.subscribers[event];
+    }
+    publish(event, change) {
+        if (!this.hasSubscribers(event))
+            return;
+        if (this.verbose || this.subscribers[event].value !== change) {
+            this.subscribers[event].value = change;
+            this.subscribers[event].handlers.forEach((handler) => {
+                handler(change, this.subscribers[event].value);
+            });
+        }
+    }
+    once(event) {
+        return new Promise((resolve) => {
+            const cb = (value) => {
+                this.unsubscribe(event, cb);
+                resolve(value);
+            };
+            this.subscribe(event, cb);
+        });
+    }
+}
+
+// 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$1 = (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$1(ALPHABET$3);
+const base32Hex = base$1(ALPHABET_HEX$1);
+const decode$9 = base32.decode;
+const decodeHex$2 = base32Hex.decode;
+const encode$8 = base32.encode;
+const encodeHex$2 = base32Hex.encode;
+const isBase32 = (string, hex = false) => {
+    try {
+        if (hex)
+            decodeHex$2(string);
+        else
+            decode$9(string);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+};
+const isBase32Hex = (string) => {
+    return isBase32(string, true);
+};
+var index$9 = {
+    encode: encode$8,
+    decode: decode$9,
+    encodeHex: encodeHex$2,
+    decodeHex: decodeHex$2,
+    isBase32,
+    isBase32Hex
+};
+
+var ALPHABET$2 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+var ALPHABET_HEX = '0123456789ABCDEFGHJKLMNPQRSTUVabcdefghijklmnopqrstuv';
+var base58 = base$1(ALPHABET$2);
+var base58Hex = base$1(ALPHABET_HEX);
+var encode$7 = base58.encode;
+var decode$8 = base58.decode;
+var encodeHex$1 = base58Hex.encode;
+var decodeHex$1 = base58Hex.decode;
+var isBase58 = function (string) {
+    try {
+        decode$8(string);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+};
+var isBase58Hex = function (string) {
+    try {
+        decodeHex$1(string);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+};
+var whatType = function (string) {
+    try {
+        decode$8(string);
+        return 'base58';
+    }
+    catch (e) {
+        try {
+            decodeHex$1(string);
+            return 'base58Hex';
+        }
+        catch (_a) {
+            return;
+        }
+    }
+};
+var base58$1 = { encode: encode$7, decode: decode$8, isBase58: isBase58, isBase58Hex: isBase58Hex, encodeHex: encodeHex$1, decodeHex: decodeHex$1, whatType: whatType };
+
+const MSB$1 = 0x80;
+const REST$1 = 0x7F;
+const MSBALL = ~REST$1;
+const INT = Math.pow(2, 31);
+const encode$6 = (num, out, offset) => {
+    if (Number.MAX_SAFE_INTEGER && num > Number.MAX_SAFE_INTEGER) {
+        encode$6.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$6.bytes = offset - oldOffset + 1;
+    return out;
+};
+
+const MSB = 0x80;
+const REST = 0x7F;
+const decode$7 = (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$7.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$7.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$8 = {
+    encode: encode$6,
+    decode: decode$7,
+    encodingLength
+};
+
+var index$7 = (input, prefix) => {
+    const encodedArray = [];
+    const length = input.reduce((total, current) => {
+        const encoded = index$8.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$6 = (typedArray, prefix) => {
+    const set = [];
+    if (prefix)
+        typedArray = typedArray.subarray(prefix.length);
+    const varintAndSub = (typedArray) => {
+        const length = index$8.decode(typedArray);
+        // remove length
+        typedArray = typedArray.subarray(index$8.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$1(ALPHABET$1);
+const decode$6 = base16.decode;
+const encode$5 = base16.encode;
+const isBase16 = (string) => {
+    try {
+        decode$6(string);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+};
+var index$5 = {
+    encode: encode$5,
+    decode: decode$6,
+    isBase16
+};
+
+const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+const base64 = base$1(ALPHABET);
+const decode$5 = base64.decode;
+const encode$4 = base64.encode;
+const isBase64 = (string) => {
+    try {
+        decode$5(string);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+};
+var index$4 = {
+    encode: encode$4,
+    decode: decode$5,
+    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$1 = (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$4.encode(uint8Array);
+const fromBase64 = (string) => index$4.decode(string);
+const toBase58 = (uint8Array) => base58$1.encode(uint8Array);
+const fromBase58 = (string) => base58$1.decode(string);
+const toBase32 = (uint8Array) => index$9.encode(uint8Array);
+const fromBase32 = (string) => index$9.decode(string);
+const toBase16 = (uint8Array) => index$5.encode(uint8Array);
+const fromBase16 = (string) => index$5.decode(string);
+let FormatInterface$2 = class FormatInterface {
+    encoded;
+    constructor(input) {
+        if (input) {
+            if (index$5.isBase16(input))
+                this.encoded = this.fromBase16(input);
+            else if (index$9.isBase32(input))
+                this.encoded = this.fromBase32(input);
+            else if (base58$1.isBase58(input))
+                this.encoded = this.fromBase58(input);
+            else if (index$4.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$4.encode(uint8Array);
+    }
+    fromBase64(string) {
+        return index$4.decode(string);
+    }
+    toBase58(uint8Array) {
+        return base58$1.encode(uint8Array);
+    }
+    fromBase58(string) {
+        return base58$1.decode(string);
+    }
+    toBase32(uint8Array) {
+        return index$9.encode(uint8Array);
+    }
+    fromBase32(string) {
+        return index$9.decode(string);
+    }
+    toBase16(uint8Array) {
+        return index$5.encode(uint8Array);
+    }
+    fromBase16(string) {
+        return index$5.decode(string);
+    }
+};
+var index$3 = {
+    fromString: fromString$1,
+    toString: toString$1,
+    fromHex,
+    toHex: toHex$1,
+    fromArrayLike,
+    toArrayLike,
+    fromUintArrayString,
+    toUintArrayString,
+    toBase64,
+    fromBase64,
+    toBase58,
+    fromBase58,
+    toBase32,
+    fromBase32,
+    toBase16,
+    fromBase16,
+    FormatInterface: FormatInterface$2
+};
+
+const { fromString, toString } = index$3;
+const isJson = (type) => type === 'object' || 'array';
+const isString = (type) => type === 'string';
+const isNumber = (type) => type === 'number';
+const isBoolean = (type) => type === 'boolean';
+const isUint8Array$1 = (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$3 = (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$7(set);
+};
+const decode$4 = (proto, uint8Array) => {
+    let deconcated = index$6(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$1(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$2 = {
+    encode: encode$3,
+    decode: decode$4
+};
+
+/*!
+ * 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();
+
+var name$9 = "sha512";
+var data$9 = "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";
+var hash$9 = "a5d1ca7c";
+var wasmJson$9 = {
+	name: name$9,
+	data: data$9,
+	hash: hash$9
+};
+
+new Mutex();
+
+new Mutex();
+/**
+ * Creates a new SHA-2 (SHA-512) hash instance
+ */
+function createSHA512() {
+    return WASMInterface(wasmJson$9, 64).then((wasm) => {
+        wasm.init(512);
+        const obj = {
+            init: () => { wasm.init(512); return obj; },
+            update: (data) => { wasm.update(data); return obj; },
+            digest: (outputType) => wasm.digest(outputType),
+            save: () => wasm.save(),
+            load: (data) => { wasm.load(data); return obj; },
+            blockSize: 128,
+            digestSize: 64,
+        };
+        return obj;
+    });
+}
+
+new Mutex();
+
+new Mutex();
+
+new Mutex();
+
+new Mutex();
+
+var name$4 = "ripemd160";
+var data$4 = "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";
+var hash$4 = "42f1de39";
+var wasmJson$4 = {
+	name: name$4,
+	data: data$4,
+	hash: hash$4
+};
+
+new Mutex();
+/**
+ * Creates a new RIPEMD-160 hash instance
+ */
+function createRIPEMD160() {
+    return WASMInterface(wasmJson$4, 20).then((wasm) => {
+        wasm.init();
+        const obj = {
+            init: () => { wasm.init(); return obj; },
+            update: (data) => { wasm.update(data); return obj; },
+            digest: (outputType) => wasm.digest(outputType),
+            save: () => wasm.save(),
+            load: (data) => { wasm.load(data); return obj; },
+            blockSize: 64,
+            digestSize: 20,
+        };
+        return obj;
+    });
+}
+
+function calculateKeyBuffer(hasher, key) {
+    const { blockSize } = hasher;
+    const buf = getUInt8Buffer(key);
+    if (buf.length > blockSize) {
+        hasher.update(buf);
+        const uintArr = hasher.digest('binary');
+        hasher.init();
+        return uintArr;
+    }
+    return new Uint8Array(buf.buffer, buf.byteOffset, buf.length);
+}
+function calculateHmac(hasher, key) {
+    hasher.init();
+    const { blockSize } = hasher;
+    const keyBuf = calculateKeyBuffer(hasher, key);
+    const keyBuffer = new Uint8Array(blockSize);
+    keyBuffer.set(keyBuf);
+    const opad = new Uint8Array(blockSize);
+    for (let i = 0; i < blockSize; i++) {
+        const v = keyBuffer[i];
+        opad[i] = v ^ 0x5C;
+        keyBuffer[i] = v ^ 0x36;
+    }
+    hasher.update(keyBuffer);
+    const obj = {
+        init: () => {
+            hasher.init();
+            hasher.update(keyBuffer);
+            return obj;
+        },
+        update: (data) => {
+            hasher.update(data);
+            return obj;
+        },
+        digest: ((outputType) => {
+            const uintArr = hasher.digest('binary');
+            hasher.init();
+            hasher.update(opad);
+            hasher.update(uintArr);
+            return hasher.digest(outputType);
+        }),
+        save: () => {
+            throw new Error('save() not supported');
+        },
+        load: () => {
+            throw new Error('load() not supported');
+        },
+        blockSize: hasher.blockSize,
+        digestSize: hasher.digestSize,
+    };
+    return obj;
+}
+/**
+ * Calculates HMAC hash
+ * @param hash Hash algorithm to use. It has to be the return value of a function like createSHA1()
+ * @param key Key (string, Buffer or TypedArray)
+ */
+function createHMAC(hash, key) {
+    if (!hash || !hash.then) {
+        throw new Error('Invalid hash function is provided! Usage: createHMAC(createMD5(), "key").');
+    }
+    return hash.then((hasher) => calculateHmac(hasher, key));
+}
+
+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$1 = {
+    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$2.encode(this.proto, data);
+    }
+    protoDecode(data) {
+        // check schema
+        return index$2.decode(this.proto, data);
+    }
+    isHex(string) {
+        return isHex(string);
+    }
+    isBase32(string) {
+        return index$9.isBase32(string);
+    }
+    isBase58(string) {
+        return base58$1.isBase58(string);
+    }
+    fromBs32(encoded) {
+        return this.decode(index$9.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$1(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$8.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$8.decode(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$1.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$1.getCodec(buffer))
+                    this.fromCodec(buffer);
+        }
+    }
+    fromEncoded(encoded) {
+        const codec = index$8.decode(encoded);
+        const name = this.getCodecName(codec);
+        this.name = name;
+        this.encoded = encoded;
+        return this.decode(encoded);
+    }
+    getCodec(name) {
+        return utils$1.getCodec(name);
+    }
+    getCodecName(codec) {
+        return utils$1.getCodecName(codec);
+    }
+    getHashAlg(name) {
+        return utils$1.getHashAlg(name);
+    }
+    fromCodec(codec) {
+        this.name = this.getCodecName(codec);
+        this.hashAlg = this.getHashAlg(this.name);
+        this.codec = this.getCodec(this.name);
+        this.codecBuffer = index$8.encode(this.codec);
+    }
+    fromName(name) {
+        const codec = this.getCodec(name);
+        this.name = name;
+        this.codec = codec;
+        this.hashAlg = this.getHashAlg(name);
+        this.codecBuffer = index$8.encode(this.codec);
+    }
+    decode(encoded) {
+        encoded = encoded || this.encoded;
+        const codec = index$8.decode(encoded);
+        this.fromCodec(codec);
+        return this.decoded;
+    }
+    encode(codec) {
+        codec = codec || this.codec;
+        this.encoded = index$8.encode(codec);
+        return this.encoded;
+    }
+};
+
+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;
+        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(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.discoCodec.codecBuffer.length);
+        uint8Array.set(length);
+        uint8Array.set(this.discoCodec.codecBuffer, length.length);
+        return uint8Array;
+    }
+    get length() {
+        return index$8.encode(this.size);
+    }
+    get buffer() {
+        return this.encoded;
+    }
+    get hash() {
+        return this.encoded;
+    }
+    fromJSON(json) {
+        return this.encode(Buffer.from(JSON.stringify(json)));
+    }
+    async encode(buffer, name) {
+        if (!this.name && name)
+            this.name = name;
+        if (!buffer)
+            buffer = this.buffer;
+        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-', '');
+            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;
+        this.codec = this.discoCodec.encode();
+        this.codec = this.discoCodec.codecBuffer;
+        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$8.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$8.decode(buffer);
+        this.discoCodec = new Codec$1(codec, this.codecs);
+        // TODO: validate codec
+        buffer = buffer.slice(index$8.decode.bytes);
+        this.size = index$8.decode(buffer);
+        this.digest = buffer.slice(index$8.decode.bytes);
+        if (this.digest.length !== this.size) {
+            throw new Error(`hash length inconsistent: 0x${this.encoded.toString('hex')}`);
+        }
+        // const discoCodec = new Codec(codec, this.codecs)
+        this.name = this.discoCodec.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 Codec = Codec$1;
+
+const BufferToUint8Array = data => {
+    if (data.type === 'Buffer') {
+        data = new Uint8Array(data.data);
+    }
+    return data;
+};
+const protoFor = (message) => {
+    const codec = new Codec(message);
+    if (!codec.name)
+        throw new Error('proto not found');
+    const Proto = globalThis.peernet.protos[codec.name];
+    if (!Proto)
+        throw (new Error(`No proto defined for ${codec.name}`));
+    return new Proto(message);
+};
+/**
+ * wether or not a peernet daemon is active
+ * @return {Boolean}
+ */
+const hasDaemon = async () => {
+    try {
+        let response = await fetch('http://127.0.0.1:1000/api/version');
+        response = await response.json();
+        return Boolean(response.client === '@peernet/api/http');
+    }
+    catch (e) {
+        return false;
+    }
+};
+const https = () => {
+    if (!globalThis.location)
+        return false;
+    return Boolean(globalThis.location.protocol === 'https:');
+};
+/**
+ * Get current environment
+ * @return {String} current environment [node, electron, browser]
+ */
+const environment = () => {
+    const _navigator = globalThis.navigator;
+    if (!_navigator) {
+        return 'node';
+    }
+    else if (_navigator && /electron/i.test(_navigator.userAgent)) {
+        return 'electron';
+    }
+    else {
+        return 'browser';
+    }
+};
+/**
+ * * Get current environment
+ * @return {Object} result
+ * @property {Boolean} reult.daemon whether or not daemon is running
+ * @property {Boolean} reult.environment Current environment
+ */
+const target = async () => {
+    let daemon = false;
+    if (!https())
+        daemon = await hasDaemon();
+    return { daemon, environment: environment() };
+};
+
+class PeerDiscovery {
+    constructor(id) {
+        this.id = id;
+    }
+    _getPeerId(id) {
+        if (!peernet.peerMap || peernet.peerMap && peernet.peerMap.size === 0)
+            return false;
+        for (const entry of [...peernet.peerMap.entries()]) {
+            for (const _id of entry[1]) {
+                if (_id === id)
+                    return entry[0];
+            }
+        }
+    }
+    async discover(peer) {
+        let id = this._getPeerId(peer.id);
+        if (id)
+            return id;
+        const data = await new peernet.protos['peernet-peer']({ id: this.id });
+        const node = await peernet.prepareMessage(peer.id, data.encoded);
+        let response = await peer.request(node.encoded);
+        response = await protoFor(response);
+        response = await new peernet.protos['peernet-peer-response'](response.decoded.data);
+        id = response.decoded.id;
+        if (id === this.id)
+            return;
+        if (!peernet.peerMap.has(id))
+            peernet.peerMap.set(id, [peer.id]);
+        else {
+            const connections = peernet.peerMap.get(id);
+            if (connections.indexOf(peer.id) === -1) {
+                connections.push(peer.id);
+                peernet.peerMap.set(peer.id, connections);
+            }
+        }
+        return id;
+    }
+    async discoverHandler(message, peer) {
+        const { id, proto } = message;
+        // if (typeof message.data === 'string') message.data = Buffer.from(message.data)
+        if (proto.name === 'peernet-peer') {
+            const from = proto.decoded.id;
+            if (from === this.id)
+                return;
+            if (!peernet.peerMap.has(from))
+                peernet.peerMap.set(from, [peer.id]);
+            else {
+                const connections = peernet.peerMap.get(from);
+                if (connections.indexOf(peer.id) === -1) {
+                    connections.push(peer.id);
+                    peernet.peerMap.set(from, connections);
+                }
+            }
+            const data = await new peernet.protos['peernet-peer-response']({ id: this.id });
+            const node = await peernet.prepareMessage(from, data.encoded);
+            peer.write(Buffer.from(JSON.stringify({ id, data: node.encoded })));
+        }
+        else if (proto.name === 'peernet-peer-response') {
+            const from = proto.decoded.id;
+            if (from === this.id)
+                return;
+            if (!peernet.peerMap.has(from))
+                peernet.peerMap.set(from, [peer.id]);
+            else {
+                const connections = peernet.peerMap.get(from);
+                if (connections.indexOf(peer.id) === -1) {
+                    connections.push(peer.id);
+                    peernet.peerMap.set(from, connections);
+                }
+            }
+        }
+    }
+}
+
+/**
+ * Keep history of fetched address and ptr
+ * @property {Object} address
+ * @property {Object} ptr
+ */
+const lastFetched = {
+    address: {
+        value: undefined,
+        timestamp: 0,
+    },
+    ptr: {
+        value: undefined,
+        timestamp: 0,
+    },
+};
+const getAddress = async () => {
+    const { address } = lastFetched;
+    const now = Math.round(new Date().getTime() / 1000);
+    if (now - address.timestamp > 1200000) {
+        address.value = await fetch('https://icanhazip.com/');
+        address.value = await address.value.text();
+        address.timestamp = Math.round(new Date().getTime() / 1000);
+        lastFetched.address = address;
+    }
+    return address.value;
+};
+const degreesToRadians = (degrees) => {
+    return degrees * Math.PI / 180;
+};
+const distanceInKmBetweenEarthCoordinates = (lat1, lon1, lat2, lon2) => {
+    const earthRadiusKm = 6371;
+    const dLat = degreesToRadians(lat2 - lat1);
+    const dLon = degreesToRadians(lon2 - lon1);
+    lat1 = degreesToRadians(lat1);
+    lat2 = degreesToRadians(lat2);
+    const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+        Math.sin(dLon / 2) * Math.sin(dLon / 2) * Math.cos(lat1) * Math.cos(lat2);
+    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+    return earthRadiusKm * c;
+};
+class DhtEarth {
+    /**
+     *
+     */
+    constructor() {
+        this.providerMap = new Map();
+    }
+    /**
+     * @param {Object} address
+     * @return {Object} {latitude: lat, longitude: lon}
+     */
+    async getCoordinates(address) {
+        // const {address} = parseAddress(provider)
+        const request = `https://whereis.leofcoin.org/?ip=${address}`;
+        let response = await fetch(request);
+        response = await response.json();
+        const { lat, lon } = response;
+        return { latitude: lat, longitude: lon };
+    }
+    /**
+     * @param {Object} peer
+     * @param {Object} provider
+     * @return {Object} {provider, distance}
+     */
+    async getDistance(peer, provider) {
+        const { latitude, longitude } = await this.getCoordinates(provider.address);
+        return { provider, distance: distanceInKmBetweenEarthCoordinates(peer.latitude, peer.longitude, latitude, longitude) };
+    }
+    /**
+     * @param {Array} providers
+     * @return {Object} closestPeer
+     */
+    async closestPeer(providers) {
+        let all = [];
+        const address = await getAddress();
+        const peerLoc = await this.getCoordinates(address);
+        for (const provider of providers) {
+            if (provider.address === '127.0.0.1')
+                all.push({ provider, distance: 0 });
+            else
+                all.push(this.getDistance(peerLoc, provider));
+        }
+        all = await Promise.all(all);
+        all = all.sort((previous, current) => previous.distance - current.distance);
+        return all[0].provider;
+    }
+    /**
+     * @param {String} hash
+     * @return {Array} providers
+     */
+    providersFor(hash) {
+        return this.providerMap.get(hash);
+    }
+    /**
+     * @param {String} address
+     * @param {String} hash
+     * @return {Array} providers
+     */
+    async addProvider(address, hash) {
+        let providers = [];
+        if (this.providerMap.has(hash))
+            providers = this.providerMap.get(hash);
+        providers = new Set([...providers, address]);
+        this.providerMap.set(hash, providers);
+        return providers;
+    }
+}
+
+class MessageHandler {
+    constructor(network) {
+        this.network = network;
+    }
+    /**
+     * hash and sign message
+     *
+     * @param {object} message
+     * @param {Buffer} message.from peer id
+     * @param {Buffer} message.to peer id
+     * @param {string} message.data Peernet message
+     * (PeernetMessage excluded) encoded as a string
+     * @return message
+     */
+    async hashAndSignMessage(message) {
+        let identity = await walletStore.get('identity');
+        identity = JSON.parse(identity);
+        if (!globalThis.MultiWallet) {
+            const importee = await Promise.resolve().then(function () { return index; });
+            globalThis.MultiWallet = importee.default;
+        }
+        const wallet = new MultiWallet(this.network);
+        wallet.recover(identity.mnemonic);
+        const hash = await message.hash();
+        message.decoded.signature = wallet.sign(hash.subarray(0, 32));
+        return message;
+    }
+    /**
+     * @param {String} from - peer id
+     * @param {String} to - peer id
+     * @param {String|PeernetMessage} data - data encoded message string
+     * or the messageNode itself
+     */
+    async prepareMessage(message) {
+        if (message.keys.includes('signature')) {
+            message = await this.hashAndSignMessage(message);
+        }
+        return message;
+    }
+}
+
+const dataHandler = async (message) => {
+    if (!message)
+        return;
+    const { data, id, from } = message;
+    const proto = await protoFor(data);
+    peernet._protoHandler({ id, proto }, peernet.client.connections[from], from);
+};
+
+const dhtError = (proto) => {
+    const text = `Received proto ${proto.name} expected peernet-dht-response`;
+    return new Error(`Routing error: ${text}`);
+};
+const nothingFoundError = (hash) => {
+    return new Error(`nothing found for ${hash}`);
+};
+
+// import base32 from '@vandeurenglenn/base32'
+// import base58 from '@vandeurenglenn/base58'
+
+// export const encodings = {
+//   base58,
+//   base32
+// }
+
+const encode$2 = (string, encoding = 'utf-8') => {
+  if (typeof string === 'string') {
+    let encoded;
+    
+    // if (encodings[encoding]) encoded = encodings[encoding].encode(encoded)    
+    encoded = new TextEncoder().encode(string);
+    return encoded
+  }
+  throw Error(`expected typeof String instead got ${string}`)
+};
+
+const decode$3 = (uint8Array, encoding) => {
+  if (uint8Array instanceof Uint8Array) {
+    let decoded;
+    // if (encodings[encoding]) decoded = encodings[encoding].decode(decoded)
+    decoded = new TextDecoder().decode(uint8Array);
+    
+    return decoded
+  }
+  throw Error(`expected typeof uint8Array instead got ${uint8Array}`)
+};
+
+const pathSepS = '/';
+class KeyPath {
+
+  /**
+   * @param {string | Uint8Array} input
+   */
+  constructor(input) {
+    if (typeof input === 'string') {
+      this.uint8Array = encode$2(input);
+    } else if (input instanceof Uint8Array) {
+      this.uint8Array = input;
+    } else if (input instanceof KeyPath) {
+      this.uint8Array = input.uint8Array;
+    } else {
+      throw new Error('Invalid keyPath, should be a String, Uint8Array or KeyPath')
+    }
+  }
+  
+  isKeyPath() {
+    return true
+  }
+
+  /**
+   * Convert to the string representation
+   *
+   * @param {import('uint8arrays/to-string').SupportedEncodings} [encoding='utf8'] - The encoding to use.
+   * @returns {string}
+   */
+  toString(encoding = 'hex') {
+    return decode$3(this.uint8Array)
+  }
+
+  /**
+   * Returns the `list` representation of this path.
+   *
+   * @returns string[]
+   *
+   * @example
+   * ```js
+   * new Key('/Comedy/MontyPython/Actor:JohnCleese').list()
+   * // => ['Comedy', 'MontyPythong', 'Actor:JohnCleese']
+   * ```
+   */
+  list() {
+    return this.toString().split(pathSepS).slice(1)
+  }
+
+}
+
+class LeofcoinStorage {
+
+  constructor(name = 'storage', root = '.leofcoin') {
+    this.name = name;
+    this.root = root;
+  }
+
+  async init(name, root) {
+    const importee = await import(globalThis.navigator ? './browser-store.js' : './store.js');
+    const Store = importee.default;
+    this.db = new Store(this.name, this.root);
+  }
+
+  async get(key) {
+    if (typeof key === 'object') return this.many('get', key);
+    return this.db.get(new KeyPath(key))
+  }
+  
+  /**
+   * 
+   * @param {*} key 
+   * @param {*} value 
+   * @returns Promise
+   */
+  put(key, value) {
+    if (typeof key === 'object') return this.many('put', key);
+    return this.db.put(new KeyPath(key), new KeyValue(value));
+  }
+
+  async has(key) {
+    if (typeof key === 'object') return this.many('has', key);
+
+    try {
+      const has = await this.db.get(new KeyPath(key));
+
+      return Boolean(has);
+    } catch (e) {
+      return false
+    }
+  }
+
+  async delete(key) {
+    return this.db.delete(new KeyPath(key))
+  }
+
+  keys(limit = -1) {
+    return this.db.keys(limit)
+  }
+
+  async values(limit = -1) {
+    return this.db.values(limit)
+  }
+
+  async many(type, _value) {
+    const jobs = [];
+
+    for (const key of Object.keys(_value)) {
+      jobs.push(this[type](key, _value[key]));
+    }
+
+    return Promise.all(jobs)
+  }
+
+  async length() {
+    const keys = await this.keys();
+    return keys.length
+  }
+
+  async size() {
+    let size = 0;
+    const query = await this.db.iterate();
+    for await (const item of query) {
+      size += item.value ? item.value.length : item[1].length;
+    }
+    return size
+  }
+
+  async clear() {
+    return this.db.clear()
+  }
+
+  async iterate() {
+    return this.db.iterate()
+  }
+
+}
 
 const randombytes = strength => crypto.getRandomValues(new Uint8Array(strength));
 
@@ -193,7 +2567,7 @@ var base58check = { encode: encode$1, decode: decode$2, encodeHex, decodeHex, is
 
 const decode$1 = (multiWif, expectedVersion, expectedCodec) => {
     const decoded = base58$1.decode(multiWif);
-    let [version, codec, privateKey] = index$2(decoded);
+    let [version, codec, privateKey] = index$6(decoded);
     version = Number(new TextDecoder().decode(version));
     codec = Number(new TextDecoder().decode(codec));
     if (expectedVersion && version !== expectedVersion)
@@ -202,9 +2576,9 @@ const decode$1 = (multiWif, expectedVersion, expectedCodec) => {
         throw new Error(`invalid codec: expected ${expectedCodec} but got ${codec}`);
     return { version, codec, privateKey };
 };
-var index = {
+var index$1 = {
     encode: (version, codec, privateKey) => {
-        return base58$1.encode(index$1([
+        return base58$1.encode(index$7([
             new TextEncoder().encode(version.toString()),
             new TextEncoder().encode(codec.toString()),
             privateKey
@@ -9799,253 +12173,55 @@ var elliptic$1 = {
 
     if (sigr.isZero() || sigs.isZero()) return 2
 
-    // Can throw `throw new Error('Unable to find sencond key candinate');`
-    let point;
-    try {
-      point = ec.recoverPubKey(msg32, sigObj, recid);
-    } catch (err) {
-      return 2
-    }
-
-    savePublicKey(output, point);
-
-    return 0
-  },
-
-  ecdh (output, pubkey, seckey, data, hashfn, xbuf, ybuf) {
-    const pair = loadPublicKey(pubkey);
-    if (pair === null) return 1
-
-    const scalar = new BN(seckey);
-    if (scalar.cmp(ecparams.n) >= 0 || scalar.isZero()) return 2
-
-    const point = pair.getPublic().mul(scalar);
-
-    if (hashfn === undefined) {
-      const data = point.encode(null, true);
-      const sha256 = ec.hash().update(data).digest();
-      for (let i = 0; i < 32; ++i) output[i] = sha256[i];
-    } else {
-      if (!xbuf) xbuf = new Uint8Array(32);
-      const x = point.getX().toArray('be', 32);
-      for (let i = 0; i < 32; ++i) xbuf[i] = x[i];
-
-      if (!ybuf) ybuf = new Uint8Array(32);
-      const y = point.getY().toArray('be', 32);
-      for (let i = 0; i < 32; ++i) ybuf[i] = y[i];
-
-      const hash = hashfn(xbuf, ybuf, data);
-
-      const isValid = hash instanceof Uint8Array && hash.length === output.length;
-      if (!isValid) return 2
-
-      output.set(hash);
-    }
-
-    return 0
-  }
-};
-
-var elliptic = lib(elliptic$1);
-
-const encode = (version, privateKey, compressed) => {
-    if (privateKey.length !== 32)
-        throw new TypeError(`Invalid privateKey length: expected 32 got ${privateKey.length}`);
-    const uint8Array = new Uint8Array(compressed ? 34 : 33);
-    uint8Array.set([Number(version)]);
-    uint8Array.set(privateKey, 1);
-    if (compressed) {
-        uint8Array.set([Number(version)], 33);
-    }
-    return base58check.encode(uint8Array);
-};
-const decode = async (wif, version) => {
-    wif = (await base58check.decode(wif)).data;
-    if (version && wif[0] !== version)
-        throw new Error('Invalid network version');
-    if (wif.length < 33 || wif.length > 34)
-        throw new Error('Invalid WIF length');
-    const comp = new TextEncoder().encode('1');
-    if (wif.length === 34 && wif[33] !== comp[0])
-        throw new Error('Invalid compression flag');
-    return {
-        version: wif[0],
-        privateKey: wif.subarray(1, 33),
-        compressed: wif.length === 33 ? false : true
-    };
-};
-var wif = { encode, decode };
-
-// see https://github.com/bitcoin/bips/blob/master/bip-0039/english.txt
-var wordlist = ["abandon", "ability", "able", "about", "above", "absent", "absorb", "abstract", "absurd", "abuse", "access", "accident", "account", "accuse", "achieve", "acid", "acoustic", "acquire", "across", "act", "action", "actor", "actress", "actual", "adapt", "add", "addict", "address", "adjust", "admit", "adult", "advance", "advice", "aerobic", "affair", "afford", "afraid", "again", "age", "agent", "agree", "ahead", "aim", "air", "airport", "aisle", "alarm", "album", "alcohol", "alert", "alien", "all", "alley", "allow", "almost", "alone", "alpha", "already", "also", "alter", "always", "amateur", "amazing", "among", "amount", "amused", "analyst", "anchor", "ancient", "anger", "angle", "angry", "animal", "ankle", "announce", "annual", "another", "answer", "antenna", "antique", "anxiety", "any", "apart", "apology", "appear", "apple", "approve", "april", "arch", "arctic", "area", "arena", "argue", "arm", "armed", "armor", "army", "around", "arrange", "arrest", "arrive", "arrow", "art", "artefact", "artist", "artwork", "ask", "aspect", "assault", "asset", "assist", "assume", "asthma", "athlete", "atom", "attack", "attend", "attitude", "attract", "auction", "audit", "august", "aunt", "author", "auto", "autumn", "average", "avocado", "avoid", "awake", "aware", "away", "awesome", "awful", "awkward", "axis", "baby", "bachelor", "bacon", "badge", "bag", "balance", "balcony", "ball", "bamboo", "banana", "banner", "bar", "barely", "bargain", "barrel", "base", "basic", "basket", "battle", "beach", "bean", "beauty", "because", "become", "beef", "before", "begin", "behave", "behind", "believe", "below", "belt", "bench", "benefit", "best", "betray", "better", "between", "beyond", "bicycle", "bid", "bike", "bind", "biology", "bird", "birth", "bitter", "black", "blade", "blame", "blanket", "blast", "bleak", "bless", "blind", "blood", "blossom", "blouse", "blue", "blur", "blush", "board", "boat", "body", "boil", "bomb", "bone", "bonus", "book", "boost", "border", "boring", "borrow", "boss", "bottom", "bounce", "box", "boy", "bracket", "brain", "brand", "brass", "brave", "bread", "breeze", "brick", "bridge", "brief", "bright", "bring", "brisk", "broccoli", "broken", "bronze", "broom", "brother", "brown", "brush", "bubble", "buddy", "budget", "buffalo", "build", "bulb", "bulk", "bullet", "bundle", "bunker", "burden", "burger", "burst", "bus", "business", "busy", "butter", "buyer", "buzz", "cabbage", "cabin", "cable", "cactus", "cage", "cake", "call", "calm", "camera", "camp", "can", "canal", "cancel", "candy", "cannon", "canoe", "canvas", "canyon", "capable", "capital", "captain", "car", "carbon", "card", "cargo", "carpet", "carry", "cart", "case", "cash", "casino", "castle", "casual", "cat", "catalog", "catch", "category", "cattle", "caught", "cause", "caution", "cave", "ceiling", "celery", "cement", "census", "century", "cereal", "certain", "chair", "chalk", "champion", "change", "chaos", "chapter", "charge", "chase", "chat", "cheap", "check", "cheese", "chef", "cherry", "chest", "chicken", "chief", "child", "chimney", "choice", "choose", "chronic", "chuckle", "chunk", "churn", "cigar", "cinnamon", "circle", "citizen", "city", "civil", "claim", "clap", "clarify", "claw", "clay", "clean", "clerk", "clever", "click", "client", "cliff", "climb", "clinic", "clip", "clock", "clog", "close", "cloth", "cloud", "clown", "club", "clump", "cluster", "clutch", "coach", "coast", "coconut", "code", "coffee", "coil", "coin", "collect", "color", "column", "combine", "come", "comfort", "comic", "common", "company", "concert", "conduct", "confirm", "congress", "connect", "consider", "control", "convince", "cook", "cool", "copper", "copy", "coral", "core", "corn", "correct", "cost", "cotton", "couch", "country", "couple", "course", "cousin", "cover", "coyote", "crack", "cradle", "craft", "cram", "crane", "crash", "crater", "crawl", "crazy", "cream", "credit", "creek", "crew", "cricket", "crime", "crisp", "critic", "crop", "cross", "crouch", "crowd", "crucial", "cruel", "cruise", "crumble", "crunch", "crush", "cry", "crystal", "cube", "culture", "cup", "cupboard", "curious", "current", "curtain", "curve", "cushion", "custom", "cute", "cycle", "dad", "damage", "damp", "dance", "danger", "daring", "dash", "daughter", "dawn", "day", "deal", "debate", "debris", "decade", "december", "decide", "decline", "decorate", "decrease", "deer", "defense", "define", "defy", "degree", "delay", "deliver", "demand", "demise", "denial", "dentist", "deny", "depart", "depend", "deposit", "depth", "deputy", "derive", "describe", "desert", "design", "desk", "despair", "destroy", "detail", "detect", "develop", "device", "devote", "diagram", "dial", "diamond", "diary", "dice", "diesel", "diet", "differ", "digital", "dignity", "dilemma", "dinner", "dinosaur", "direct", "dirt", "disagree", "discover", "disease", "dish", "dismiss", "disorder", "display", "distance", "divert", "divide", "divorce", "dizzy", "doctor", "document", "dog", "doll", "dolphin", "domain", "donate", "donkey", "donor", "door", "dose", "double", "dove", "draft", "dragon", "drama", "drastic", "draw", "dream", "dress", "drift", "drill", "drink", "drip", "drive", "drop", "drum", "dry", "duck", "dumb", "dune", "during", "dust", "dutch", "duty", "dwarf", "dynamic", "eager", "eagle", "early", "earn", "earth", "easily", "east", "easy", "echo", "ecology", "economy", "edge", "edit", "educate", "effort", "egg", "eight", "either", "elbow", "elder", "electric", "elegant", "element", "elephant", "elevator", "elite", "else", "embark", "embody", "embrace", "emerge", "emotion", "employ", "empower", "empty", "enable", "enact", "end", "endless", "endorse", "enemy", "energy", "enforce", "engage", "engine", "enhance", "enjoy", "enlist", "enough", "enrich", "enroll", "ensure", "enter", "entire", "entry", "envelope", "episode", "equal", "equip", "era", "erase", "erode", "erosion", "error", "erupt", "escape", "essay", "essence", "estate", "eternal", "ethics", "evidence", "evil", "evoke", "evolve", "exact", "example", "excess", "exchange", "excite", "exclude", "excuse", "execute", "exercise", "exhaust", "exhibit", "exile", "exist", "exit", "exotic", "expand", "expect", "expire", "explain", "expose", "express", "extend", "extra", "eye", "eyebrow", "fabric", "face", "faculty", "fade", "faint", "faith", "fall", "false", "fame", "family", "famous", "fan", "fancy", "fantasy", "farm", "fashion", "fat", "fatal", "father", "fatigue", "fault", "favorite", "feature", "february", "federal", "fee", "feed", "feel", "female", "fence", "festival", "fetch", "fever", "few", "fiber", "fiction", "field", "figure", "file", "film", "filter", "final", "find", "fine", "finger", "finish", "fire", "firm", "first", "fiscal", "fish", "fit", "fitness", "fix", "flag", "flame", "flash", "flat", "flavor", "flee", "flight", "flip", "float", "flock", "floor", "flower", "fluid", "flush", "fly", "foam", "focus", "fog", "foil", "fold", "follow", "food", "foot", "force", "forest", "forget", "fork", "fortune", "forum", "forward", "fossil", "foster", "found", "fox", "fragile", "frame", "frequent", "fresh", "friend", "fringe", "frog", "front", "frost", "frown", "frozen", "fruit", "fuel", "fun", "funny", "furnace", "fury", "future", "gadget", "gain", "galaxy", "gallery", "game", "gap", "garage", "garbage", "garden", "garlic", "garment", "gas", "gasp", "gate", "gather", "gauge", "gaze", "general", "genius", "genre", "gentle", "genuine", "gesture", "ghost", "giant", "gift", "giggle", "ginger", "giraffe", "girl", "give", "glad", "glance", "glare", "glass", "glide", "glimpse", "globe", "gloom", "glory", "glove", "glow", "glue", "goat", "goddess", "gold", "good", "goose", "gorilla", "gospel", "gossip", "govern", "gown", "grab", "grace", "grain", "grant", "grape", "grass", "gravity", "great", "green", "grid", "grief", "grit", "grocery", "group", "grow", "grunt", "guard", "guess", "guide", "guilt", "guitar", "gun", "gym", "habit", "hair", "half", "hammer", "hamster", "hand", "happy", "harbor", "hard", "harsh", "harvest", "hat", "have", "hawk", "hazard", "head", "health", "heart", "heavy", "hedgehog", "height", "hello", "helmet", "help", "hen", "hero", "hidden", "high", "hill", "hint", "hip", "hire", "history", "hobby", "hockey", "hold", "hole", "holiday", "hollow", "home", "honey", "hood", "hope", "horn", "horror", "horse", "hospital", "host", "hotel", "hour", "hover", "hub", "huge", "human", "humble", "humor", "hundred", "hungry", "hunt", "hurdle", "hurry", "hurt", "husband", "hybrid", "ice", "icon", "idea", "identify", "idle", "ignore", "ill", "illegal", "illness", "image", "imitate", "immense", "immune", "impact", "impose", "improve", "impulse", "inch", "include", "income", "increase", "index", "indicate", "indoor", "industry", "infant", "inflict", "inform", "inhale", "inherit", "initial", "inject", "injury", "inmate", "inner", "innocent", "input", "inquiry", "insane", "insect", "inside", "inspire", "install", "intact", "interest", "into", "invest", "invite", "involve", "iron", "island", "isolate", "issue", "item", "ivory", "jacket", "jaguar", "jar", "jazz", "jealous", "jeans", "jelly", "jewel", "job", "join", "joke", "journey", "joy", "judge", "juice", "jump", "jungle", "junior", "junk", "just", "kangaroo", "keen", "keep", "ketchup", "key", "kick", "kid", "kidney", "kind", "kingdom", "kiss", "kit", "kitchen", "kite", "kitten", "kiwi", "knee", "knife", "knock", "know", "lab", "label", "labor", "ladder", "lady", "lake", "lamp", "language", "laptop", "large", "later", "latin", "laugh", "laundry", "lava", "law", "lawn", "lawsuit", "layer", "lazy", "leader", "leaf", "learn", "leave", "lecture", "left", "leg", "legal", "legend", "leisure", "lemon", "lend", "length", "lens", "leopard", "lesson", "letter", "level", "liar", "liberty", "library", "license", "life", "lift", "light", "like", "limb", "limit", "link", "lion", "liquid", "list", "little", "live", "lizard", "load", "loan", "lobster", "local", "lock", "logic", "lonely", "long", "loop", "lottery", "loud", "lounge", "love", "loyal", "lucky", "luggage", "lumber", "lunar", "lunch", "luxury", "lyrics", "machine", "mad", "magic", "magnet", "maid", "mail", "main", "major", "make", "mammal", "man", "manage", "mandate", "mango", "mansion", "manual", "maple", "marble", "march", "margin", "marine", "market", "marriage", "mask", "mass", "master", "match", "material", "math", "matrix", "matter", "maximum", "maze", "meadow", "mean", "measure", "meat", "mechanic", "medal", "media", "melody", "melt", "member", "memory", "mention", "menu", "mercy", "merge", "merit", "merry", "mesh", "message", "metal", "method", "middle", "midnight", "milk", "million", "mimic", "mind", "minimum", "minor", "minute", "miracle", "mirror", "misery", "miss", "mistake", "mix", "mixed", "mixture", "mobile", "model", "modify", "mom", "moment", "monitor", "monkey", "monster", "month", "moon", "moral", "more", "morning", "mosquito", "mother", "motion", "motor", "mountain", "mouse", "move", "movie", "much", "muffin", "mule", "multiply", "muscle", "museum", "mushroom", "music", "must", "mutual", "myself", "mystery", "myth", "naive", "name", "napkin", "narrow", "nasty", "nation", "nature", "near", "neck", "need", "negative", "neglect", "neither", "nephew", "nerve", "nest", "net", "network", "neutral", "never", "news", "next", "nice", "night", "noble", "noise", "nominee", "noodle", "normal", "north", "nose", "notable", "note", "nothing", "notice", "novel", "now", "nuclear", "number", "nurse", "nut", "oak", "obey", "object", "oblige", "obscure", "observe", "obtain", "obvious", "occur", "ocean", "october", "odor", "off", "offer", "office", "often", "oil", "okay", "old", "olive", "olympic", "omit", "once", "one", "onion", "online", "only", "open", "opera", "opinion", "oppose", "option", "orange", "orbit", "orchard", "order", "ordinary", "organ", "orient", "original", "orphan", "ostrich", "other", "outdoor", "outer", "output", "outside", "oval", "oven", "over", "own", "owner", "oxygen", "oyster", "ozone", "pact", "paddle", "page", "pair", "palace", "palm", "panda", "panel", "panic", "panther", "paper", "parade", "parent", "park", "parrot", "party", "pass", "patch", "path", "patient", "patrol", "pattern", "pause", "pave", "payment", "peace", "peanut", "pear", "peasant", "pelican", "pen", "penalty", "pencil", "people", "pepper", "perfect", "permit", "person", "pet", "phone", "photo", "phrase", "physical", "piano", "picnic", "picture", "piece", "pig", "pigeon", "pill", "pilot", "pink", "pioneer", "pipe", "pistol", "pitch", "pizza", "place", "planet", "plastic", "plate", "play", "please", "pledge", "pluck", "plug", "plunge", "poem", "poet", "point", "polar", "pole", "police", "pond", "pony", "pool", "popular", "portion", "position", "possible", "post", "potato", "pottery", "poverty", "powder", "power", "practice", "praise", "predict", "prefer", "prepare", "present", "pretty", "prevent", "price", "pride", "primary", "print", "priority", "prison", "private", "prize", "problem", "process", "produce", "profit", "program", "project", "promote", "proof", "property", "prosper", "protect", "proud", "provide", "public", "pudding", "pull", "pulp", "pulse", "pumpkin", "punch", "pupil", "puppy", "purchase", "purity", "purpose", "purse", "push", "put", "puzzle", "pyramid", "quality", "quantum", "quarter", "question", "quick", "quit", "quiz", "quote", "rabbit", "raccoon", "race", "rack", "radar", "radio", "rail", "rain", "raise", "rally", "ramp", "ranch", "random", "range", "rapid", "rare", "rate", "rather", "raven", "raw", "razor", "ready", "real", "reason", "rebel", "rebuild", "recall", "receive", "recipe", "record", "recycle", "reduce", "reflect", "reform", "refuse", "region", "regret", "regular", "reject", "relax", "release", "relief", "rely", "remain", "remember", "remind", "remove", "render", "renew", "rent", "reopen", "repair", "repeat", "replace", "report", "require", "rescue", "resemble", "resist", "resource", "response", "result", "retire", "retreat", "return", "reunion", "reveal", "review", "reward", "rhythm", "rib", "ribbon", "rice", "rich", "ride", "ridge", "rifle", "right", "rigid", "ring", "riot", "ripple", "risk", "ritual", "rival", "river", "road", "roast", "robot", "robust", "rocket", "romance", "roof", "rookie", "room", "rose", "rotate", "rough", "round", "route", "royal", "rubber", "rude", "rug", "rule", "run", "runway", "rural", "sad", "saddle", "sadness", "safe", "sail", "salad", "salmon", "salon", "salt", "salute", "same", "sample", "sand", "satisfy", "satoshi", "sauce", "sausage", "save", "say", "scale", "scan", "scare", "scatter", "scene", "scheme", "school", "science", "scissors", "scorpion", "scout", "scrap", "screen", "script", "scrub", "sea", "search", "season", "seat", "second", "secret", "section", "security", "seed", "seek", "segment", "select", "sell", "seminar", "senior", "sense", "sentence", "series", "service", "session", "settle", "setup", "seven", "shadow", "shaft", "shallow", "share", "shed", "shell", "sheriff", "shield", "shift", "shine", "ship", "shiver", "shock", "shoe", "shoot", "shop", "short", "shoulder", "shove", "shrimp", "shrug", "shuffle", "shy", "sibling", "sick", "side", "siege", "sight", "sign", "silent", "silk", "silly", "silver", "similar", "simple", "since", "sing", "siren", "sister", "situate", "six", "size", "skate", "sketch", "ski", "skill", "skin", "skirt", "skull", "slab", "slam", "sleep", "slender", "slice", "slide", "slight", "slim", "slogan", "slot", "slow", "slush", "small", "smart", "smile", "smoke", "smooth", "snack", "snake", "snap", "sniff", "snow", "soap", "soccer", "social", "sock", "soda", "soft", "solar", "soldier", "solid", "solution", "solve", "someone", "song", "soon", "sorry", "sort", "soul", "sound", "soup", "source", "south", "space", "spare", "spatial", "spawn", "speak", "special", "speed", "spell", "spend", "sphere", "spice", "spider", "spike", "spin", "spirit", "split", "spoil", "sponsor", "spoon", "sport", "spot", "spray", "spread", "spring", "spy", "square", "squeeze", "squirrel", "stable", "stadium", "staff", "stage", "stairs", "stamp", "stand", "start", "state", "stay", "steak", "steel", "stem", "step", "stereo", "stick", "still", "sting", "stock", "stomach", "stone", "stool", "story", "stove", "strategy", "street", "strike", "strong", "struggle", "student", "stuff", "stumble", "style", "subject", "submit", "subway", "success", "such", "sudden", "suffer", "sugar", "suggest", "suit", "summer", "sun", "sunny", "sunset", "super", "supply", "supreme", "sure", "surface", "surge", "surprise", "surround", "survey", "suspect", "sustain", "swallow", "swamp", "swap", "swarm", "swear", "sweet", "swift", "swim", "swing", "switch", "sword", "symbol", "symptom", "syrup", "system", "table", "tackle", "tag", "tail", "talent", "talk", "tank", "tape", "target", "task", "taste", "tattoo", "taxi", "teach", "team", "tell", "ten", "tenant", "tennis", "tent", "term", "test", "text", "thank", "that", "theme", "then", "theory", "there", "they", "thing", "this", "thought", "three", "thrive", "throw", "thumb", "thunder", "ticket", "tide", "tiger", "tilt", "timber", "time", "tiny", "tip", "tired", "tissue", "title", "toast", "tobacco", "today", "toddler", "toe", "together", "toilet", "token", "tomato", "tomorrow", "tone", "tongue", "tonight", "tool", "tooth", "top", "topic", "topple", "torch", "tornado", "tortoise", "toss", "total", "tourist", "toward", "tower", "town", "toy", "track", "trade", "traffic", "tragic", "train", "transfer", "trap", "trash", "travel", "tray", "treat", "tree", "trend", "trial", "tribe", "trick", "trigger", "trim", "trip", "trophy", "trouble", "truck", "true", "truly", "trumpet", "trust", "truth", "try", "tube", "tuition", "tumble", "tuna", "tunnel", "turkey", "turn", "turtle", "twelve", "twenty", "twice", "twin", "twist", "two", "type", "typical", "ugly", "umbrella", "unable", "unaware", "uncle", "uncover", "under", "undo", "unfair", "unfold", "unhappy", "uniform", "unique", "unit", "universe", "unknown", "unlock", "until", "unusual", "unveil", "update", "upgrade", "uphold", "upon", "upper", "upset", "urban", "urge", "usage", "use", "used", "useful", "useless", "usual", "utility", "vacant", "vacuum", "vague", "valid", "valley", "valve", "van", "vanish", "vapor", "various", "vast", "vault", "vehicle", "velvet", "vendor", "venture", "venue", "verb", "verify", "version", "very", "vessel", "veteran", "viable", "vibrant", "vicious", "victory", "video", "view", "village", "vintage", "violin", "virtual", "virus", "visa", "visit", "visual", "vital", "vivid", "vocal", "voice", "void", "volcano", "volume", "vote", "voyage", "wage", "wagon", "wait", "walk", "wall", "walnut", "want", "warfare", "warm", "warrior", "wash", "wasp", "waste", "water", "wave", "way", "wealth", "weapon", "wear", "weasel", "weather", "web", "wedding", "weekend", "weird", "welcome", "west", "wet", "whale", "what", "wheat", "wheel", "when", "where", "whip", "whisper", "wide", "width", "wife", "wild", "will", "win", "window", "wine", "wing", "wink", "winner", "winter", "wire", "wisdom", "wise", "wish", "witness", "wolf", "woman", "wonder", "wood", "wool", "word", "work", "world", "worry", "worth", "wrap", "wreck", "wrestle", "wrist", "write", "wrong", "yard", "year", "yellow", "you", "young", "youth", "zebra", "zero", "zone", "zoo"];
-
-class Mnemonic {
-    wordlist;
-    constructor(options) {
-        // english always loaded, rest included by dev    
-        this.wordlist = options?.wordlist || wordlist;
-    }
-    lpad(string, padString, length) {
-        while (string.length < length) {
-            string = padString + string;
-        }
-        return string;
-    }
-    normalize(string) {
-        return (string || '').normalize('NFKD');
-    }
-    bytesToBinary(bytes) {
-        return bytes.map((byte) => this.lpad(byte.toString(2), '0', 8)).join('');
-    }
-    async deriveChecksumBits(entropyBuffer) {
-        const entropy = entropyBuffer.length * 8;
-        const cs = entropy / 32;
-        const hash = await createHash(entropyBuffer, 'SHA-512');
-        return this.bytesToBinary(Array.from(hash)).slice(0, cs);
-    }
-    async mnemonicFromEntropy(entropyBuffer) {
-        let checksum = await this.deriveChecksumBits(entropyBuffer);
-        const entropy = this.bytesToBinary(Array.from(entropyBuffer));
-        let bits = entropy + checksum;
-        return bits
-            .match(/(.{1,11})/g)
-            .map((binary) => {
-            const index = parseInt(binary, 2);
-            return this.wordlist[index];
-        }).join(' ');
-    }
-    generate(strength = 256) {
-        return this.mnemonicFromEntropy(randombytes(strength / 8));
-    }
-    salt(password) {
-        return 'mnemonic' + this.normalize(password);
-    }
-    seedFromMnemonic(mnemonic, password, strength = 256, iterations = 2048) {
-        const encoder = new TextEncoder();
-        return pbkdf2(encoder.encode(this.salt(password)), encoder.encode(this.normalize(mnemonic)), iterations, strength, 'SHA-512');
-    }
-}
-
-class MultiSignature {
-    multiCodec;
-    version;
-    decoded;
-    encoded;
-    #multiSignature;
-    constructor(version, multiCodec) {
-        if (version === undefined)
-            throw ReferenceError('version undefined');
-        if (multiCodec === undefined)
-            throw ReferenceError('multicodec undefined');
-        this.multiCodec = multiCodec;
-        this.version = version;
-    }
-    get signature() {
-        return this.decoded.signature;
-    }
-    get multiSignature() {
-        return this.#multiSignature || this.encoded || this.encode(this.signature);
-    }
-    export() {
-        return base58$1.encode(this.multiSignature);
-    }
-    import(encoded) {
-        return base58$1.decode(encoded);
-    }
-    sign(hash, privateKey) {
-        if (!hash || !privateKey)
-            throw ReferenceError(`${hash ? 'privateKey' : 'hash'} undefined`);
-        const { signature } = elliptic.ecdsaSign(hash, privateKey);
-        this.decoded = {
-            version: this.version,
-            multiCodec: this.multiCodec,
-            signature
-        };
-        return this.encode(signature);
-    }
-    /**
-   * verify signature (multiSignature.signature)
-   */
-    verifySignature(signature, hash, publicKey) {
-        return elliptic.ecdsaVerify(signature, hash, publicKey);
-    }
-    /**
-   * verify multiSignature
-   */
-    verify(multiSignature, hash, publicKey) {
-        multiSignature = this.decode(multiSignature);
-        return elliptic.ecdsaVerify(multiSignature.signature, hash, publicKey);
-    }
-    encode(signature) {
-        signature = signature || this.signature;
-        if (!signature)
-            throw ReferenceError('signature undefined');
-        this.#multiSignature = typedArrayConcat([
-            index$3.encode(this.version),
-            index$3.encode(this.multiCodec),
-            signature
-        ]);
-        return this.multiSignature;
-    }
-    /**
-   * decode exported multi signature to object
-   * @param {multiSignature} multiSignature base58 encoded string
-   * @return {decodedMultiSignature} { version, multiCodec, signature }
-   */
-    decode(multiSignature) {
-        if (multiSignature)
-            this.#multiSignature = multiSignature;
-        if (!this.multiSignature)
-            throw ReferenceError('multiSignature undefined');
-        let buffer = this.multiSignature;
-        const version = index$3.decode(buffer);
-        buffer = buffer.subarray(index$3.decode.bytes);
-        const codec = index$3.decode(buffer);
-        buffer = buffer.subarray(index$3.decode.bytes);
-        const signature = buffer.subarray(0, buffer.length);
-        if (version !== this.version)
-            throw TypeError('Invalid version');
-        if (this.multiCodec !== codec)
-            throw TypeError('Invalid multiCodec');
-        this.decoded = {
-            version,
-            multiCodec: codec,
-            signature
-        };
-        return this.decoded;
-    }
-    toString() {
-        return this.multiSignature.toString();
-    }
-    fromString(string) {
-        return this.decode(new Uint8Array(string.split(',')));
-    }
-    toBs58() {
-        return base58$1.encode(this.multiSignature);
-    }
-    fromBs58(string) {
-        return this.decode(base58$1.decode(string));
-    }
-    toBs32() {
-        return index$4.encode(this.multiSignature);
-    }
-    fromBs32(string) {
-        return this.decode(index$4.decode(string));
-    }
-    toBs32Hex() {
-        return index$4.encodeHex(this.multiSignature);
-    }
-    fromBs32Hex(string) {
-        return this.decode(index$4.decodeHex(string));
-    }
-    toBs58Hex() {
-        return base58$1.encodeHex(this.multiSignature);
-    }
-    fromBs58Hex(string) {
-        return this.decode(base58$1.decodeHex(string));
-    }
-}
-
+    // Can throw `throw new Error('Unable to find sencond key candinate');`
+    let point;
+    try {
+      point = ec.recoverPubKey(msg32, sigObj, recid);
+    } catch (err) {
+      return 2
+    }
+
+    savePublicKey(output, point);
+
+    return 0
+  },
+
+  ecdh (output, pubkey, seckey, data, hashfn, xbuf, ybuf) {
+    const pair = loadPublicKey(pubkey);
+    if (pair === null) return 1
+
+    const scalar = new BN(seckey);
+    if (scalar.cmp(ecparams.n) >= 0 || scalar.isZero()) return 2
+
+    const point = pair.getPublic().mul(scalar);
+
+    if (hashfn === undefined) {
+      const data = point.encode(null, true);
+      const sha256 = ec.hash().update(data).digest();
+      for (let i = 0; i < 32; ++i) output[i] = sha256[i];
+    } else {
+      if (!xbuf) xbuf = new Uint8Array(32);
+      const x = point.getX().toArray('be', 32);
+      for (let i = 0; i < 32; ++i) xbuf[i] = x[i];
+
+      if (!ybuf) ybuf = new Uint8Array(32);
+      const y = point.getY().toArray('be', 32);
+      for (let i = 0; i < 32; ++i) ybuf[i] = y[i];
+
+      const hash = hashfn(xbuf, ybuf, data);
+
+      const isValid = hash instanceof Uint8Array && hash.length === output.length;
+      if (!isValid) return 2
+
+      output.set(hash);
+    }
+
+    return 0
+  }
+};
+
+var elliptic = lib(elliptic$1);
+
 const leofcoinOlivia = {
     messagePrefix: '\u0019Leofcoin Signed Message:',
     version: 1,
@@ -10149,6 +12325,34 @@ var networks = {
     ethereum
 };
 
+const encode = (version, privateKey, compressed) => {
+    if (privateKey.length !== 32)
+        throw new TypeError(`Invalid privateKey length: expected 32 got ${privateKey.length}`);
+    const uint8Array = new Uint8Array(compressed ? 34 : 33);
+    uint8Array.set([Number(version)]);
+    uint8Array.set(privateKey, 1);
+    if (compressed) {
+        uint8Array.set([Number(version)], 33);
+    }
+    return base58check.encode(uint8Array);
+};
+const decode = async (wif, version) => {
+    wif = (await base58check.decode(wif)).data;
+    if (version && wif[0] !== version)
+        throw new Error('Invalid network version');
+    if (wif.length < 33 || wif.length > 34)
+        throw new Error('Invalid WIF length');
+    const comp = new TextEncoder().encode('1');
+    if (wif.length === 34 && wif[33] !== comp[0])
+        throw new Error('Invalid compression flag');
+    return {
+        version: wif[0],
+        privateKey: wif.subarray(1, 33),
+        compressed: wif.length === 33 ? false : true
+    };
+};
+var wif = { encode, decode };
+
 const HIGHEST_BIT = 0x80000000;
 const { publicKeyCreate, publicKeyVerify, privateKeyVerify, privateKeyTweakAdd, ecdh } = elliptic;
 class HdNode {
@@ -10239,7 +12443,7 @@ class HdNode {
         else {
             set.push(new Uint8Array(this.publicKey));
         }
-        return base58check.encode(index$1(set));
+        return base58check.encode(index$7(set));
     }
     toWIF() {
         if (!this.#privateKey)
@@ -10255,14 +12459,14 @@ class HdNode {
             if (this.isNeutered)
                 throw new TypeError('Missing private key for hardened child key');
             // data = 0x00 || ser256(kpar) || ser32(index)
-            data = index$1([
+            data = index$7([
                 new TextEncoder().encode('0'),
                 this.privateKey,
                 new TextEncoder().encode(index.toString())
             ]);
         }
         else {
-            data = index$1([
+            data = index$7([
                 this.publicKey,
                 new TextEncoder().encode(index.toString())
             ]);
@@ -10326,7 +12530,7 @@ class HdNode {
         let buffer = (await base58check.decode(string)).data;
         network = network || networks.leofcoin;
         // 4 bytes: version bytes
-        let [version, depth, parentFingerprint, index, chainCode, k, privateKey] = index$2(buffer);
+        let [version, depth, parentFingerprint, index, chainCode, k, privateKey] = index$6(buffer);
         version = Number(new TextDecoder().decode(version));
         depth = Number(new TextDecoder().decode(depth));
         parentFingerprint = Number(new TextDecoder().decode(parentFingerprint));
@@ -10350,6 +12554,56 @@ class HdNode {
     }
 }
 
+// see https://github.com/bitcoin/bips/blob/master/bip-0039/english.txt
+var wordlist = ["abandon", "ability", "able", "about", "above", "absent", "absorb", "abstract", "absurd", "abuse", "access", "accident", "account", "accuse", "achieve", "acid", "acoustic", "acquire", "across", "act", "action", "actor", "actress", "actual", "adapt", "add", "addict", "address", "adjust", "admit", "adult", "advance", "advice", "aerobic", "affair", "afford", "afraid", "again", "age", "agent", "agree", "ahead", "aim", "air", "airport", "aisle", "alarm", "album", "alcohol", "alert", "alien", "all", "alley", "allow", "almost", "alone", "alpha", "already", "also", "alter", "always", "amateur", "amazing", "among", "amount", "amused", "analyst", "anchor", "ancient", "anger", "angle", "angry", "animal", "ankle", "announce", "annual", "another", "answer", "antenna", "antique", "anxiety", "any", "apart", "apology", "appear", "apple", "approve", "april", "arch", "arctic", "area", "arena", "argue", "arm", "armed", "armor", "army", "around", "arrange", "arrest", "arrive", "arrow", "art", "artefact", "artist", "artwork", "ask", "aspect", "assault", "asset", "assist", "assume", "asthma", "athlete", "atom", "attack", "attend", "attitude", "attract", "auction", "audit", "august", "aunt", "author", "auto", "autumn", "average", "avocado", "avoid", "awake", "aware", "away", "awesome", "awful", "awkward", "axis", "baby", "bachelor", "bacon", "badge", "bag", "balance", "balcony", "ball", "bamboo", "banana", "banner", "bar", "barely", "bargain", "barrel", "base", "basic", "basket", "battle", "beach", "bean", "beauty", "because", "become", "beef", "before", "begin", "behave", "behind", "believe", "below", "belt", "bench", "benefit", "best", "betray", "better", "between", "beyond", "bicycle", "bid", "bike", "bind", "biology", "bird", "birth", "bitter", "black", "blade", "blame", "blanket", "blast", "bleak", "bless", "blind", "blood", "blossom", "blouse", "blue", "blur", "blush", "board", "boat", "body", "boil", "bomb", "bone", "bonus", "book", "boost", "border", "boring", "borrow", "boss", "bottom", "bounce", "box", "boy", "bracket", "brain", "brand", "brass", "brave", "bread", "breeze", "brick", "bridge", "brief", "bright", "bring", "brisk", "broccoli", "broken", "bronze", "broom", "brother", "brown", "brush", "bubble", "buddy", "budget", "buffalo", "build", "bulb", "bulk", "bullet", "bundle", "bunker", "burden", "burger", "burst", "bus", "business", "busy", "butter", "buyer", "buzz", "cabbage", "cabin", "cable", "cactus", "cage", "cake", "call", "calm", "camera", "camp", "can", "canal", "cancel", "candy", "cannon", "canoe", "canvas", "canyon", "capable", "capital", "captain", "car", "carbon", "card", "cargo", "carpet", "carry", "cart", "case", "cash", "casino", "castle", "casual", "cat", "catalog", "catch", "category", "cattle", "caught", "cause", "caution", "cave", "ceiling", "celery", "cement", "census", "century", "cereal", "certain", "chair", "chalk", "champion", "change", "chaos", "chapter", "charge", "chase", "chat", "cheap", "check", "cheese", "chef", "cherry", "chest", "chicken", "chief", "child", "chimney", "choice", "choose", "chronic", "chuckle", "chunk", "churn", "cigar", "cinnamon", "circle", "citizen", "city", "civil", "claim", "clap", "clarify", "claw", "clay", "clean", "clerk", "clever", "click", "client", "cliff", "climb", "clinic", "clip", "clock", "clog", "close", "cloth", "cloud", "clown", "club", "clump", "cluster", "clutch", "coach", "coast", "coconut", "code", "coffee", "coil", "coin", "collect", "color", "column", "combine", "come", "comfort", "comic", "common", "company", "concert", "conduct", "confirm", "congress", "connect", "consider", "control", "convince", "cook", "cool", "copper", "copy", "coral", "core", "corn", "correct", "cost", "cotton", "couch", "country", "couple", "course", "cousin", "cover", "coyote", "crack", "cradle", "craft", "cram", "crane", "crash", "crater", "crawl", "crazy", "cream", "credit", "creek", "crew", "cricket", "crime", "crisp", "critic", "crop", "cross", "crouch", "crowd", "crucial", "cruel", "cruise", "crumble", "crunch", "crush", "cry", "crystal", "cube", "culture", "cup", "cupboard", "curious", "current", "curtain", "curve", "cushion", "custom", "cute", "cycle", "dad", "damage", "damp", "dance", "danger", "daring", "dash", "daughter", "dawn", "day", "deal", "debate", "debris", "decade", "december", "decide", "decline", "decorate", "decrease", "deer", "defense", "define", "defy", "degree", "delay", "deliver", "demand", "demise", "denial", "dentist", "deny", "depart", "depend", "deposit", "depth", "deputy", "derive", "describe", "desert", "design", "desk", "despair", "destroy", "detail", "detect", "develop", "device", "devote", "diagram", "dial", "diamond", "diary", "dice", "diesel", "diet", "differ", "digital", "dignity", "dilemma", "dinner", "dinosaur", "direct", "dirt", "disagree", "discover", "disease", "dish", "dismiss", "disorder", "display", "distance", "divert", "divide", "divorce", "dizzy", "doctor", "document", "dog", "doll", "dolphin", "domain", "donate", "donkey", "donor", "door", "dose", "double", "dove", "draft", "dragon", "drama", "drastic", "draw", "dream", "dress", "drift", "drill", "drink", "drip", "drive", "drop", "drum", "dry", "duck", "dumb", "dune", "during", "dust", "dutch", "duty", "dwarf", "dynamic", "eager", "eagle", "early", "earn", "earth", "easily", "east", "easy", "echo", "ecology", "economy", "edge", "edit", "educate", "effort", "egg", "eight", "either", "elbow", "elder", "electric", "elegant", "element", "elephant", "elevator", "elite", "else", "embark", "embody", "embrace", "emerge", "emotion", "employ", "empower", "empty", "enable", "enact", "end", "endless", "endorse", "enemy", "energy", "enforce", "engage", "engine", "enhance", "enjoy", "enlist", "enough", "enrich", "enroll", "ensure", "enter", "entire", "entry", "envelope", "episode", "equal", "equip", "era", "erase", "erode", "erosion", "error", "erupt", "escape", "essay", "essence", "estate", "eternal", "ethics", "evidence", "evil", "evoke", "evolve", "exact", "example", "excess", "exchange", "excite", "exclude", "excuse", "execute", "exercise", "exhaust", "exhibit", "exile", "exist", "exit", "exotic", "expand", "expect", "expire", "explain", "expose", "express", "extend", "extra", "eye", "eyebrow", "fabric", "face", "faculty", "fade", "faint", "faith", "fall", "false", "fame", "family", "famous", "fan", "fancy", "fantasy", "farm", "fashion", "fat", "fatal", "father", "fatigue", "fault", "favorite", "feature", "february", "federal", "fee", "feed", "feel", "female", "fence", "festival", "fetch", "fever", "few", "fiber", "fiction", "field", "figure", "file", "film", "filter", "final", "find", "fine", "finger", "finish", "fire", "firm", "first", "fiscal", "fish", "fit", "fitness", "fix", "flag", "flame", "flash", "flat", "flavor", "flee", "flight", "flip", "float", "flock", "floor", "flower", "fluid", "flush", "fly", "foam", "focus", "fog", "foil", "fold", "follow", "food", "foot", "force", "forest", "forget", "fork", "fortune", "forum", "forward", "fossil", "foster", "found", "fox", "fragile", "frame", "frequent", "fresh", "friend", "fringe", "frog", "front", "frost", "frown", "frozen", "fruit", "fuel", "fun", "funny", "furnace", "fury", "future", "gadget", "gain", "galaxy", "gallery", "game", "gap", "garage", "garbage", "garden", "garlic", "garment", "gas", "gasp", "gate", "gather", "gauge", "gaze", "general", "genius", "genre", "gentle", "genuine", "gesture", "ghost", "giant", "gift", "giggle", "ginger", "giraffe", "girl", "give", "glad", "glance", "glare", "glass", "glide", "glimpse", "globe", "gloom", "glory", "glove", "glow", "glue", "goat", "goddess", "gold", "good", "goose", "gorilla", "gospel", "gossip", "govern", "gown", "grab", "grace", "grain", "grant", "grape", "grass", "gravity", "great", "green", "grid", "grief", "grit", "grocery", "group", "grow", "grunt", "guard", "guess", "guide", "guilt", "guitar", "gun", "gym", "habit", "hair", "half", "hammer", "hamster", "hand", "happy", "harbor", "hard", "harsh", "harvest", "hat", "have", "hawk", "hazard", "head", "health", "heart", "heavy", "hedgehog", "height", "hello", "helmet", "help", "hen", "hero", "hidden", "high", "hill", "hint", "hip", "hire", "history", "hobby", "hockey", "hold", "hole", "holiday", "hollow", "home", "honey", "hood", "hope", "horn", "horror", "horse", "hospital", "host", "hotel", "hour", "hover", "hub", "huge", "human", "humble", "humor", "hundred", "hungry", "hunt", "hurdle", "hurry", "hurt", "husband", "hybrid", "ice", "icon", "idea", "identify", "idle", "ignore", "ill", "illegal", "illness", "image", "imitate", "immense", "immune", "impact", "impose", "improve", "impulse", "inch", "include", "income", "increase", "index", "indicate", "indoor", "industry", "infant", "inflict", "inform", "inhale", "inherit", "initial", "inject", "injury", "inmate", "inner", "innocent", "input", "inquiry", "insane", "insect", "inside", "inspire", "install", "intact", "interest", "into", "invest", "invite", "involve", "iron", "island", "isolate", "issue", "item", "ivory", "jacket", "jaguar", "jar", "jazz", "jealous", "jeans", "jelly", "jewel", "job", "join", "joke", "journey", "joy", "judge", "juice", "jump", "jungle", "junior", "junk", "just", "kangaroo", "keen", "keep", "ketchup", "key", "kick", "kid", "kidney", "kind", "kingdom", "kiss", "kit", "kitchen", "kite", "kitten", "kiwi", "knee", "knife", "knock", "know", "lab", "label", "labor", "ladder", "lady", "lake", "lamp", "language", "laptop", "large", "later", "latin", "laugh", "laundry", "lava", "law", "lawn", "lawsuit", "layer", "lazy", "leader", "leaf", "learn", "leave", "lecture", "left", "leg", "legal", "legend", "leisure", "lemon", "lend", "length", "lens", "leopard", "lesson", "letter", "level", "liar", "liberty", "library", "license", "life", "lift", "light", "like", "limb", "limit", "link", "lion", "liquid", "list", "little", "live", "lizard", "load", "loan", "lobster", "local", "lock", "logic", "lonely", "long", "loop", "lottery", "loud", "lounge", "love", "loyal", "lucky", "luggage", "lumber", "lunar", "lunch", "luxury", "lyrics", "machine", "mad", "magic", "magnet", "maid", "mail", "main", "major", "make", "mammal", "man", "manage", "mandate", "mango", "mansion", "manual", "maple", "marble", "march", "margin", "marine", "market", "marriage", "mask", "mass", "master", "match", "material", "math", "matrix", "matter", "maximum", "maze", "meadow", "mean", "measure", "meat", "mechanic", "medal", "media", "melody", "melt", "member", "memory", "mention", "menu", "mercy", "merge", "merit", "merry", "mesh", "message", "metal", "method", "middle", "midnight", "milk", "million", "mimic", "mind", "minimum", "minor", "minute", "miracle", "mirror", "misery", "miss", "mistake", "mix", "mixed", "mixture", "mobile", "model", "modify", "mom", "moment", "monitor", "monkey", "monster", "month", "moon", "moral", "more", "morning", "mosquito", "mother", "motion", "motor", "mountain", "mouse", "move", "movie", "much", "muffin", "mule", "multiply", "muscle", "museum", "mushroom", "music", "must", "mutual", "myself", "mystery", "myth", "naive", "name", "napkin", "narrow", "nasty", "nation", "nature", "near", "neck", "need", "negative", "neglect", "neither", "nephew", "nerve", "nest", "net", "network", "neutral", "never", "news", "next", "nice", "night", "noble", "noise", "nominee", "noodle", "normal", "north", "nose", "notable", "note", "nothing", "notice", "novel", "now", "nuclear", "number", "nurse", "nut", "oak", "obey", "object", "oblige", "obscure", "observe", "obtain", "obvious", "occur", "ocean", "october", "odor", "off", "offer", "office", "often", "oil", "okay", "old", "olive", "olympic", "omit", "once", "one", "onion", "online", "only", "open", "opera", "opinion", "oppose", "option", "orange", "orbit", "orchard", "order", "ordinary", "organ", "orient", "original", "orphan", "ostrich", "other", "outdoor", "outer", "output", "outside", "oval", "oven", "over", "own", "owner", "oxygen", "oyster", "ozone", "pact", "paddle", "page", "pair", "palace", "palm", "panda", "panel", "panic", "panther", "paper", "parade", "parent", "park", "parrot", "party", "pass", "patch", "path", "patient", "patrol", "pattern", "pause", "pave", "payment", "peace", "peanut", "pear", "peasant", "pelican", "pen", "penalty", "pencil", "people", "pepper", "perfect", "permit", "person", "pet", "phone", "photo", "phrase", "physical", "piano", "picnic", "picture", "piece", "pig", "pigeon", "pill", "pilot", "pink", "pioneer", "pipe", "pistol", "pitch", "pizza", "place", "planet", "plastic", "plate", "play", "please", "pledge", "pluck", "plug", "plunge", "poem", "poet", "point", "polar", "pole", "police", "pond", "pony", "pool", "popular", "portion", "position", "possible", "post", "potato", "pottery", "poverty", "powder", "power", "practice", "praise", "predict", "prefer", "prepare", "present", "pretty", "prevent", "price", "pride", "primary", "print", "priority", "prison", "private", "prize", "problem", "process", "produce", "profit", "program", "project", "promote", "proof", "property", "prosper", "protect", "proud", "provide", "public", "pudding", "pull", "pulp", "pulse", "pumpkin", "punch", "pupil", "puppy", "purchase", "purity", "purpose", "purse", "push", "put", "puzzle", "pyramid", "quality", "quantum", "quarter", "question", "quick", "quit", "quiz", "quote", "rabbit", "raccoon", "race", "rack", "radar", "radio", "rail", "rain", "raise", "rally", "ramp", "ranch", "random", "range", "rapid", "rare", "rate", "rather", "raven", "raw", "razor", "ready", "real", "reason", "rebel", "rebuild", "recall", "receive", "recipe", "record", "recycle", "reduce", "reflect", "reform", "refuse", "region", "regret", "regular", "reject", "relax", "release", "relief", "rely", "remain", "remember", "remind", "remove", "render", "renew", "rent", "reopen", "repair", "repeat", "replace", "report", "require", "rescue", "resemble", "resist", "resource", "response", "result", "retire", "retreat", "return", "reunion", "reveal", "review", "reward", "rhythm", "rib", "ribbon", "rice", "rich", "ride", "ridge", "rifle", "right", "rigid", "ring", "riot", "ripple", "risk", "ritual", "rival", "river", "road", "roast", "robot", "robust", "rocket", "romance", "roof", "rookie", "room", "rose", "rotate", "rough", "round", "route", "royal", "rubber", "rude", "rug", "rule", "run", "runway", "rural", "sad", "saddle", "sadness", "safe", "sail", "salad", "salmon", "salon", "salt", "salute", "same", "sample", "sand", "satisfy", "satoshi", "sauce", "sausage", "save", "say", "scale", "scan", "scare", "scatter", "scene", "scheme", "school", "science", "scissors", "scorpion", "scout", "scrap", "screen", "script", "scrub", "sea", "search", "season", "seat", "second", "secret", "section", "security", "seed", "seek", "segment", "select", "sell", "seminar", "senior", "sense", "sentence", "series", "service", "session", "settle", "setup", "seven", "shadow", "shaft", "shallow", "share", "shed", "shell", "sheriff", "shield", "shift", "shine", "ship", "shiver", "shock", "shoe", "shoot", "shop", "short", "shoulder", "shove", "shrimp", "shrug", "shuffle", "shy", "sibling", "sick", "side", "siege", "sight", "sign", "silent", "silk", "silly", "silver", "similar", "simple", "since", "sing", "siren", "sister", "situate", "six", "size", "skate", "sketch", "ski", "skill", "skin", "skirt", "skull", "slab", "slam", "sleep", "slender", "slice", "slide", "slight", "slim", "slogan", "slot", "slow", "slush", "small", "smart", "smile", "smoke", "smooth", "snack", "snake", "snap", "sniff", "snow", "soap", "soccer", "social", "sock", "soda", "soft", "solar", "soldier", "solid", "solution", "solve", "someone", "song", "soon", "sorry", "sort", "soul", "sound", "soup", "source", "south", "space", "spare", "spatial", "spawn", "speak", "special", "speed", "spell", "spend", "sphere", "spice", "spider", "spike", "spin", "spirit", "split", "spoil", "sponsor", "spoon", "sport", "spot", "spray", "spread", "spring", "spy", "square", "squeeze", "squirrel", "stable", "stadium", "staff", "stage", "stairs", "stamp", "stand", "start", "state", "stay", "steak", "steel", "stem", "step", "stereo", "stick", "still", "sting", "stock", "stomach", "stone", "stool", "story", "stove", "strategy", "street", "strike", "strong", "struggle", "student", "stuff", "stumble", "style", "subject", "submit", "subway", "success", "such", "sudden", "suffer", "sugar", "suggest", "suit", "summer", "sun", "sunny", "sunset", "super", "supply", "supreme", "sure", "surface", "surge", "surprise", "surround", "survey", "suspect", "sustain", "swallow", "swamp", "swap", "swarm", "swear", "sweet", "swift", "swim", "swing", "switch", "sword", "symbol", "symptom", "syrup", "system", "table", "tackle", "tag", "tail", "talent", "talk", "tank", "tape", "target", "task", "taste", "tattoo", "taxi", "teach", "team", "tell", "ten", "tenant", "tennis", "tent", "term", "test", "text", "thank", "that", "theme", "then", "theory", "there", "they", "thing", "this", "thought", "three", "thrive", "throw", "thumb", "thunder", "ticket", "tide", "tiger", "tilt", "timber", "time", "tiny", "tip", "tired", "tissue", "title", "toast", "tobacco", "today", "toddler", "toe", "together", "toilet", "token", "tomato", "tomorrow", "tone", "tongue", "tonight", "tool", "tooth", "top", "topic", "topple", "torch", "tornado", "tortoise", "toss", "total", "tourist", "toward", "tower", "town", "toy", "track", "trade", "traffic", "tragic", "train", "transfer", "trap", "trash", "travel", "tray", "treat", "tree", "trend", "trial", "tribe", "trick", "trigger", "trim", "trip", "trophy", "trouble", "truck", "true", "truly", "trumpet", "trust", "truth", "try", "tube", "tuition", "tumble", "tuna", "tunnel", "turkey", "turn", "turtle", "twelve", "twenty", "twice", "twin", "twist", "two", "type", "typical", "ugly", "umbrella", "unable", "unaware", "uncle", "uncover", "under", "undo", "unfair", "unfold", "unhappy", "uniform", "unique", "unit", "universe", "unknown", "unlock", "until", "unusual", "unveil", "update", "upgrade", "uphold", "upon", "upper", "upset", "urban", "urge", "usage", "use", "used", "useful", "useless", "usual", "utility", "vacant", "vacuum", "vague", "valid", "valley", "valve", "van", "vanish", "vapor", "various", "vast", "vault", "vehicle", "velvet", "vendor", "venture", "venue", "verb", "verify", "version", "very", "vessel", "veteran", "viable", "vibrant", "vicious", "victory", "video", "view", "village", "vintage", "violin", "virtual", "virus", "visa", "visit", "visual", "vital", "vivid", "vocal", "voice", "void", "volcano", "volume", "vote", "voyage", "wage", "wagon", "wait", "walk", "wall", "walnut", "want", "warfare", "warm", "warrior", "wash", "wasp", "waste", "water", "wave", "way", "wealth", "weapon", "wear", "weasel", "weather", "web", "wedding", "weekend", "weird", "welcome", "west", "wet", "whale", "what", "wheat", "wheel", "when", "where", "whip", "whisper", "wide", "width", "wife", "wild", "will", "win", "window", "wine", "wing", "wink", "winner", "winter", "wire", "wisdom", "wise", "wish", "witness", "wolf", "woman", "wonder", "wood", "wool", "word", "work", "world", "worry", "worth", "wrap", "wreck", "wrestle", "wrist", "write", "wrong", "yard", "year", "yellow", "you", "young", "youth", "zebra", "zero", "zone", "zoo"];
+
+class Mnemonic {
+    wordlist;
+    constructor(options) {
+        // english always loaded, rest included by dev    
+        this.wordlist = options?.wordlist || wordlist;
+    }
+    lpad(string, padString, length) {
+        while (string.length < length) {
+            string = padString + string;
+        }
+        return string;
+    }
+    normalize(string) {
+        return (string || '').normalize('NFKD');
+    }
+    bytesToBinary(bytes) {
+        return bytes.map((byte) => this.lpad(byte.toString(2), '0', 8)).join('');
+    }
+    async deriveChecksumBits(entropyBuffer) {
+        const entropy = entropyBuffer.length * 8;
+        const cs = entropy / 32;
+        const hash = await createHash(entropyBuffer, 'SHA-512');
+        return this.bytesToBinary(Array.from(hash)).slice(0, cs);
+    }
+    async mnemonicFromEntropy(entropyBuffer) {
+        let checksum = await this.deriveChecksumBits(entropyBuffer);
+        const entropy = this.bytesToBinary(Array.from(entropyBuffer));
+        let bits = entropy + checksum;
+        return bits
+            .match(/(.{1,11})/g)
+            .map((binary) => {
+            const index = parseInt(binary, 2);
+            return this.wordlist[index];
+        }).join(' ');
+    }
+    generate(strength = 256) {
+        return this.mnemonicFromEntropy(randombytes(strength / 8));
+    }
+    salt(password) {
+        return 'mnemonic' + this.normalize(password);
+    }
+    seedFromMnemonic(mnemonic, password, strength = 256, iterations = 2048) {
+        const encoder = new TextEncoder();
+        return pbkdf2(encoder.encode(this.salt(password)), encoder.encode(this.normalize(mnemonic)), iterations, strength, 'SHA-512');
+    }
+}
+
 const fromNetworkString = network => {
     const parts = network.split(':');
     network = networks[parts[0]];
@@ -10452,51 +12706,171 @@ class HDWallet {
         await this.defineHDNode(await (new HdNode()).fromSeed(new Uint8Array(seed), network));
         return mnemonic;
     }
-    /**
-   * recover using mnemonic (recovery word list)
-   */
-    async recover(mnemonic, password, network) {
-        network = this.validateNetwork(network || password);
-        const seed = await new Mnemonic().seedFromMnemonic(mnemonic, password, 512);
-        let node = new HdNode();
-        node = await node.fromSeed(new Uint8Array(seed), network);
-        await this.defineHDNode(await node.fromSeed(new Uint8Array(seed), network));
+    /**
+   * recover using mnemonic (recovery word list)
+   */
+    async recover(mnemonic, password, network) {
+        network = this.validateNetwork(network || password);
+        const seed = await new Mnemonic().seedFromMnemonic(mnemonic, password, 512);
+        let node = new HdNode();
+        node = await node.fromSeed(new Uint8Array(seed), network);
+        await this.defineHDNode(await node.fromSeed(new Uint8Array(seed), network));
+    }
+    async load(base58, network) {
+        network = this.validateNetwork(network);
+        await this.defineHDNode(await (new HdNode()).fromBase58(base58, network));
+    }
+    save() {
+        return this.hdnode.toBase58();
+    }
+    async fromAddress(address, chainCode, network) {
+        network = this.validateNetwork(network);
+        address = (await base58check.decode(address)).data;
+        if (!chainCode || chainCode && !Buffer.isBuffer(chainCode))
+            chainCode = address.slice(1);
+        await this.defineHDNode(await (new HdNode()).fromPublicKey(address, chainCode, network));
+    }
+    async fromPublicKey(hex, chainCode, network) {
+        network = this.validateNetwork(network);
+        if (!chainCode || chainCode)
+            chainCode = hex.slice(1);
+        let node = new HdNode();
+        node = await node.fromPublicKey(hex, chainCode, network);
+        await this.defineHDNode(node);
+        return this;
+    }
+    async fromPrivateKey(privateKey, chainCode, network) {
+        await this.defineHDNode(await (new HdNode()).fromPrivateKey(privateKey, chainCode, network));
+    }
+}
+
+class MultiSignature {
+    multiCodec;
+    version;
+    decoded;
+    encoded;
+    #multiSignature;
+    constructor(version, multiCodec) {
+        if (version === undefined)
+            throw ReferenceError('version undefined');
+        if (multiCodec === undefined)
+            throw ReferenceError('multicodec undefined');
+        this.multiCodec = multiCodec;
+        this.version = version;
+    }
+    get signature() {
+        return this.decoded.signature;
+    }
+    get multiSignature() {
+        return this.#multiSignature || this.encoded || this.encode(this.signature);
+    }
+    export() {
+        return base58$1.encode(this.multiSignature);
+    }
+    import(encoded) {
+        return base58$1.decode(encoded);
+    }
+    sign(hash, privateKey) {
+        if (!hash || !privateKey)
+            throw ReferenceError(`${hash ? 'privateKey' : 'hash'} undefined`);
+        const { signature } = elliptic.ecdsaSign(hash, privateKey);
+        this.decoded = {
+            version: this.version,
+            multiCodec: this.multiCodec,
+            signature
+        };
+        return this.encode(signature);
+    }
+    /**
+   * verify signature (multiSignature.signature)
+   */
+    verifySignature(signature, hash, publicKey) {
+        return elliptic.ecdsaVerify(signature, hash, publicKey);
+    }
+    /**
+   * verify multiSignature
+   */
+    verify(multiSignature, hash, publicKey) {
+        multiSignature = this.decode(multiSignature);
+        return elliptic.ecdsaVerify(multiSignature.signature, hash, publicKey);
+    }
+    encode(signature) {
+        signature = signature || this.signature;
+        if (!signature)
+            throw ReferenceError('signature undefined');
+        this.#multiSignature = typedArrayConcat([
+            index$8.encode(this.version),
+            index$8.encode(this.multiCodec),
+            signature
+        ]);
+        return this.multiSignature;
+    }
+    /**
+   * decode exported multi signature to object
+   * @param {multiSignature} multiSignature base58 encoded string
+   * @return {decodedMultiSignature} { version, multiCodec, signature }
+   */
+    decode(multiSignature) {
+        if (multiSignature)
+            this.#multiSignature = multiSignature;
+        if (!this.multiSignature)
+            throw ReferenceError('multiSignature undefined');
+        let buffer = this.multiSignature;
+        const version = index$8.decode(buffer);
+        buffer = buffer.subarray(index$8.decode.bytes);
+        const codec = index$8.decode(buffer);
+        buffer = buffer.subarray(index$8.decode.bytes);
+        const signature = buffer.subarray(0, buffer.length);
+        if (version !== this.version)
+            throw TypeError('Invalid version');
+        if (this.multiCodec !== codec)
+            throw TypeError('Invalid multiCodec');
+        this.decoded = {
+            version,
+            multiCodec: codec,
+            signature
+        };
+        return this.decoded;
+    }
+    toString() {
+        return this.multiSignature.toString();
+    }
+    fromString(string) {
+        return this.decode(new Uint8Array(string.split(',')));
+    }
+    toBs58() {
+        return base58$1.encode(this.multiSignature);
+    }
+    fromBs58(string) {
+        return this.decode(base58$1.decode(string));
     }
-    async load(base58, network) {
-        network = this.validateNetwork(network);
-        await this.defineHDNode(await (new HdNode()).fromBase58(base58, network));
+    toBs32() {
+        return index$9.encode(this.multiSignature);
     }
-    save() {
-        return this.hdnode.toBase58();
+    fromBs32(string) {
+        return this.decode(index$9.decode(string));
     }
-    async fromAddress(address, chainCode, network) {
-        network = this.validateNetwork(network);
-        address = (await base58check.decode(address)).data;
-        if (!chainCode || chainCode && !Buffer.isBuffer(chainCode))
-            chainCode = address.slice(1);
-        await this.defineHDNode(await (new HdNode()).fromPublicKey(address, chainCode, network));
+    toBs32Hex() {
+        return index$9.encodeHex(this.multiSignature);
     }
-    async fromPublicKey(hex, chainCode, network) {
-        network = this.validateNetwork(network);
-        if (!chainCode || chainCode)
-            chainCode = hex.slice(1);
-        let node = new HdNode();
-        node = await node.fromPublicKey(hex, chainCode, network);
-        await this.defineHDNode(node);
-        return this;
+    fromBs32Hex(string) {
+        return this.decode(index$9.decodeHex(string));
     }
-    async fromPrivateKey(privateKey, chainCode, network) {
-        await this.defineHDNode(await (new HdNode()).fromPrivateKey(privateKey, chainCode, network));
+    toBs58Hex() {
+        return base58$1.encodeHex(this.multiSignature);
+    }
+    fromBs58Hex(string) {
+        return this.decode(base58$1.decodeHex(string));
     }
 }
 
-class MultiWallet extends HDWallet {
+class MultiHDNode extends HDWallet {
     #encrypted;
     constructor(network, hdnode) {
         super(network, hdnode);
     }
     get id() {
-        return base58check.encode(index$1([
+        return base58check.encode(index$7([
             new TextEncoder().encode(this.version.toString()),
             this.account(0).hdnode.neutered.publicKey
         ]));
@@ -10504,13 +12878,10 @@ class MultiWallet extends HDWallet {
     get multiWIF() {
         return this.toMultiWif();
     }
-    get neutered() {
-        return new HDAccount(this.networkName, this, this.hdnode.depth);
-    }
     async fromId(id) {
         let buffer = (await base58check.decode(id)).data;
-        index$3.decode(buffer);
-        buffer = buffer.slice(index$3.decode.bytes);
+        index$8.decode(buffer);
+        buffer = buffer.slice(index$8.decode.bytes);
         this.fromPublicKey(buffer, null, this.networkName);
     }
     async lock(multiWIF) {
@@ -10526,7 +12897,7 @@ class MultiWallet extends HDWallet {
         this.locked = false;
     }
     fromMultiWif(string) {
-        const { version, codec, privateKey } = index.decode(string);
+        const { version, codec, privateKey } = index$1.decode(string);
         this.network = Object.values(networks).reduce((p, c) => {
             if (c.multiCodec === codec)
                 return c;
@@ -10540,7 +12911,7 @@ class MultiWallet extends HDWallet {
         return this.fromPrivateKey(privateKey, undefined, this.network);
     }
     toMultiWif() {
-        return index.encode(this.network.version, this.network.multiCodec, this.privateKey);
+        return index$1.encode(this.network.version, this.network.multiCodec, this.privateKey);
     }
     sign(hash) {
         return new MultiSignature(this.version, this.network.multiCodec)
@@ -10550,6 +12921,51 @@ class MultiWallet extends HDWallet {
         return new MultiSignature(this.version, this.network.multiCodec)
             .verify(multiSignature, hash, this.publicKey);
     }
+}
+
+class HDAccount extends MultiHDNode {
+    /**
+     * @param {number} depth - acount depth
+     */
+    constructor(network, hdnode, depth = 0) {
+        super(network, hdnode);
+        this.hdnode = hdnode;
+        this.depth = depth;
+        this._prefix = `m/44'/${hdnode.network.coin_type}'/${depth}'/`;
+    }
+    get neutered() {
+        return this.hdnode.neutered;
+    }
+    /**
+     * @param {number} index - address index
+     */
+    async internal(index = 0) {
+        return this.hdnode.derivePath(`${this._prefix}1/${index}`);
+    }
+    /**
+     * @param {number} index - address index
+     */
+    async external(index = 0) {
+        return this.hdnode.derivePath(`${this._prefix}0/${index}`);
+    }
+}
+
+let MultiWallet$1 = class MultiWallet extends MultiHDNode {
+    constructor(network, hdnode) {
+        super(network, hdnode);
+    }
+    get id() {
+        return base58check.encode(index$7([
+            new TextEncoder().encode(this.version.toString()),
+            this.account(0).hdnode.neutered.publicKey
+        ]));
+    }
+    get multiWIF() {
+        return this.toMultiWif();
+    }
+    get neutered() {
+        return new HDAccount(this.networkName, this, this.hdnode.depth);
+    }
     /**
      * @param {number} account - account to return chain for
      * @return internal(addressIndex), external(addressIndex)
@@ -10557,45 +12973,725 @@ class MultiWallet extends HDWallet {
     account(index) {
         return new HDAccount(this.networkName, this, index);
     }
+    async fromAccount(privateKey, depth, network) {
+        const node = await new MultiWallet$1(network).fromPrivateKey(privateKey);
+        return new HDAccount(node, depth);
+    }
     /**
      * m / purpose' / coin_type' / account' / change / aadress_index
      *
      * see https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki
      */
     async derivePath(path) {
-        return new MultiWallet(this.networkName, await this.hdnode.derivePath(path));
+        return new MultiWallet$1(this.networkName, await this.hdnode.derivePath(path));
     }
     async derive(index) {
-        return new MultiWallet(this.networkName, await this.hdnode.derive(index));
+        return new MultiWallet$1(this.networkName, await this.hdnode.derive(index));
     }
-    async fromAccount(privateKey, depth, network) {
-        const node = await new MultiWallet(network).fromPrivateKey(privateKey);
-        return new HDAccount(node, depth);
+};
+
+var index = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  default: MultiWallet$1
+});
+
+const walletStore$1 = globalThis.walletStore;
+const accountStore = globalThis.accountStore;
+class Identity {
+    #wallet;
+    network;
+    id;
+    constructor(network) {
+        this.network = network;
+    }
+    get accounts() {
+        return this.getAccounts();
+    }
+    async getAccounts() {
+        let accounts = await walletStore$1.get('accounts');
+        accounts = new TextDecoder().decode(accounts);
+        return JSON.parse(accounts);
+    }
+    async load(password) {
+        let importee;
+        if (!password) {
+            if (globalThis.navigator)
+                importee = await import('./browser.js');
+            else {
+                const path = await import('node:path');
+                const { fileURLToPath } = await import('node:url');
+                const __filename = fileURLToPath(import.meta.url);
+                const __dirname = path.dirname(__filename);
+                const url = path.join(__dirname, './prompts/password/node.js');
+                importee = await import(url);
+            }
+            password = await importee.default();
+        }
+        const accountExists = await accountStore.has('public');
+        if (accountExists) {
+            const pub = await accountStore.get('public');
+            this.id = JSON.parse(new TextDecoder().decode(pub)).walletId;
+            const selected = await walletStore$1.get('selected-account');
+            globalThis.peernet.selectedAccount = new TextDecoder().decode(selected);
+        }
+        else {
+            const importee = await import(/* webpackChunkName: "generate-account" */ './index-5a93c9c3.js');
+            const { identity, accounts } = await importee.default(password, this.network);
+            await accountStore.put('public', JSON.stringify({ walletId: identity.walletId }));
+            await walletStore$1.put('version', String(1));
+            await walletStore$1.put('accounts', JSON.stringify(accounts));
+            await walletStore$1.put('selected-account', accounts[0][1]);
+            await walletStore$1.put('identity', JSON.stringify(identity));
+            globalThis.peernet.selectedAccount = accounts[0][1];
+            this.id = identity.walletId;
+        }
+        const identity = JSON.parse(new TextDecoder().decode(await walletStore$1.get('identity')));
+        this.#wallet = new MultiWallet$1(this.network);
+        await this.#wallet.recover(identity.mnemonic, password, this.network);
+    }
+    async export(password) {
+        if (!password)
+            throw new Error('IdentityExportError: password required');
+        const identity = JSON.parse(new TextDecoder().decode(await walletStore$1.get('identity')));
+        this.#wallet = new MultiWallet$1(this.network);
+        await this.#wallet.recover(identity.mnemonic, password, this.network);
+        return this.#wallet.toMultiWif();
+    }
+    async import(multiWIF) {
+        this.#wallet = new MultiWallet$1(this.network);
+        await this.#wallet.fromMultiWif(multiWIF);
+    }
+    async unlock({ key, iv, cipher }) {
     }
-}
-// TODO: multihash addresses
-class HDAccount extends MultiWallet {
     /**
-     * @param {number} depth - acount depth
+     * Lock current wallet or import wallet using a MultiWIF and lock
+     *
+     * @param password
+     * @param multiWIF
      */
-    constructor(network, hdnode, depth = 0) {
-        super(network, hdnode);
-        this.hdnode = hdnode;
-        this.depth = depth;
-        this._prefix = `m/44'/${hdnode.network.coin_type}'/${depth}'/`;
+    async lock(password, multiWIF) {
     }
+}
+
+globalThis.LeofcoinStorage = LeofcoinStorage;
+globalThis.leofcoin = globalThis.leofcoin || {};
+globalThis.pubsub = globalThis.pubsub || new LittlePubSub();
+globalThis.globalSub = globalThis.globalSub || new LittlePubSub(true);
+/**
+ * @access public
+ * @example
+ * const peernet = new Peernet();
+ */
+class Peernet {
+    identity;
+    stores = [];
     /**
-     * @param {number} index - address index
+     * @type {Object}
+     * @property {Object} peer Instance of Peer
      */
-    async internal(index = 0) {
-        return this.hdnode.derivePath(`${this._prefix}1/${index}`);
+    dht = new DhtEarth();
+    /** @leofcoin/peernet-swarm/client */
+    client;
+    network;
+    stars;
+    networkVersion;
+    bw;
+    /**
+     * @access public
+     * @param {Object} options
+     * @param {String} options.network - desired network
+     * @param {String} options.stars - star list for selected network (these should match, don't mix networks)
+     * @param {String} options.root - path to root directory
+     * @param {String} options.storePrefix - prefix for datatores (lfc)
+     *
+     * @return {Promise} instance of Peernet
+     *
+     * @example
+     * const peernet = new Peernet({network: 'leofcoin', root: '.leofcoin'});
+     */
+    constructor(options) {
+        /**
+         * @property {String} network - current network
+         */
+        this.network = options.network || 'leofcoin';
+        this.stars = options.stars;
+        const parts = this.network.split(':');
+        this.networkVersion = options.networkVersion || parts.length > 1 ? parts[1] : 'mainnet';
+        if (!options.storePrefix)
+            options.storePrefix = 'lfc';
+        if (!options.port)
+            options.port = 2000;
+        if (!options.root) {
+            parts[1] ? options.root = `.${parts[0]}/${parts[1]}` : options.root = `.${this.network}`;
+        }
+        globalThis.peernet = this;
+        this.bw = {
+            up: 0,
+            down: 0,
+        };
+        return this._init(options);
+    }
+    get id() {
+        return this.identity.id;
+    }
+    get accounts() {
+        return this.identity.accounts;
+    }
+    get defaultStores() {
+        return ['account', 'wallet', 'block', 'transaction', 'chain', 'data', 'message'];
+    }
+    addProto(name, proto) {
+        if (!globalThis.peernet.protos[name])
+            globalThis.peernet.protos[name] = proto;
+    }
+    addCodec(codec) {
+        return utils$1.addCodec(codec);
+    }
+    async addStore(name, prefix, root, isPrivate = true) {
+        if (name === 'block' || name === 'transaction' || name === 'chain' ||
+            name === 'data' || name === 'message')
+            isPrivate = false;
+        let Storage;
+        this.hasDaemon ? Storage = LeofcoinStorageClient : Storage = LeofcoinStorage;
+        if (!globalThis[`${name}Store`]) {
+            globalThis[`${name}Store`] = new Storage(name, root);
+            await globalThis[`${name}Store`].init();
+        }
+        globalThis[`${name}Store`].private = isPrivate;
+        if (!isPrivate)
+            this.stores.push(name);
     }
     /**
-     * @param {number} index - address index
+     * @see MessageHandler
      */
-    async external(index = 0) {
-        return this.hdnode.derivePath(`${this._prefix}0/${index}`);
+    prepareMessage(data) {
+        return this._messageHandler.prepareMessage(data);
     }
-}
+    /**
+     * @access public
+     *
+     * @return {Array} peerId
+     */
+    get peers() {
+        return Object.keys(this.client.connections);
+    }
+    get connections() {
+        return Object.values(this.client.connections);
+    }
+    get peerEntries() {
+        return Object.entries(this.client.connections);
+    }
+    /**
+     * @return {String} id - peerId
+     */
+    getConnection(id) {
+        return this.client.connections[id];
+    }
+    /**
+     * @private
+     *
+     * @param {Object} options
+     * @param {String} options.root - path to root directory
+     *
+     * @return {Promise} instance of Peernet
+     */
+    async _init(options) {
+        this.requestProtos = {};
+        this.storePrefix = options.storePrefix;
+        this.root = options.root;
+        const { RequestMessage, ResponseMessage, PeerMessage, PeerMessageResponse, PeernetMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PsMessage, ChatMessage, PeernetFile
+        // FolderMessageResponse
+         } = await import(/* webpackChunkName: "messages" */ './messages-c820f513.js');
+        /**
+         * proto Object containing protos
+         * @type {Object}
+         * @property {PeernetMessage} protos[peernet-message] messageNode
+         * @property {DHTMessage} protos[peernet-dht] messageNode
+         * @property {DHTMessageResponse} protos[peernet-dht-response] messageNode
+         * @property {DataMessage} protos[peernet-data] messageNode
+         * @property {DataMessageResponse} protos[peernet-data-response] messageNode
+         */
+        globalThis.peernet.protos = {
+            'peernet-request': RequestMessage,
+            'peernet-response': ResponseMessage,
+            'peernet-peer': PeerMessage,
+            'peernet-peer-response': PeerMessageResponse,
+            'peernet-message': PeernetMessage,
+            'peernet-dht': DHTMessage,
+            'peernet-dht-response': DHTMessageResponse,
+            'peernet-data': DataMessage,
+            'peernet-data-response': DataMessageResponse,
+            'peernet-ps': PsMessage,
+            'chat-message': ChatMessage,
+            'peernet-file': PeernetFile
+        };
+        this._messageHandler = new MessageHandler(this.network);
+        const { daemon, environment } = await target();
+        this.hasDaemon = daemon;
+        for (const store of this.defaultStores) {
+            await this.addStore(store, options.storePrefix, options.root);
+        }
+        this.identity = new Identity(this.network);
+        await this.identity.load();
+        this._peerHandler = new PeerDiscovery(this.id);
+        this.peerId = this.id;
+        pubsub.subscribe('peer:connected', async (peer) => {
+            // console.log(peer);
+            // console.log({connected: peer.id, as: this._getPeerId(peer.id) });
+            // peer.on('peernet.data', async (message) => {
+            //   const id = message.id
+            //   message = new PeernetMessage(Buffer.from(message.data.data))
+            //   const proto = protoFor(message.decoded.data)
+            //   this._protoHandler({id, proto}, peer)
+            // })
+        });
+        /**
+         * converts data -> message -> proto
+         * @see DataHandler
+         */
+        pubsub.subscribe('peer:data', dataHandler);
+        const importee = await import('./client-94d84d27.js');
+        /**
+         * @access public
+         * @type {PeernetClient}
+         */
+        this.client = new importee.default(this.id, this.networkVersion, this.stars);
+        if (globalThis.navigator) {
+            globalThis.addEventListener('beforeunload', async () => this.client.close());
+        }
+        else {
+            process.on('SIGTERM', async () => {
+                process.stdin.resume();
+                await this.client.close();
+                process.exit();
+            });
+        }
+        return this;
+    }
+    addRequestHandler(name, method) {
+        this.requestProtos[name] = method;
+    }
+    sendMessage(peer, id, data) {
+        if (peer.readyState === 'open') {
+            peer.send(data, id);
+            this.bw.up += data.length;
+        }
+        else if (peer.readyState === 'closed') ;
+    }
+    async handleDHT(peer, id, proto) {
+        let { hash, store } = proto.decoded;
+        let has;
+        if (store) {
+            store = globalThis[`${store}Store`];
+            has = store.private ? false : await store.has(hash);
+        }
+        else {
+            has = await this.has(hash);
+        }
+        const data = await new globalThis.peernet.protos['peernet-dht-response']({ hash, has });
+        const node = await this.prepareMessage(data);
+        this.sendMessage(peer, id, node.encoded);
+    }
+    async handleData(peer, id, proto) {
+        let { hash, store } = proto.decoded;
+        let data;
+        store = globalThis[`${store}Store`] || await this.whichStore([...this.stores], hash);
+        if (store && !store.private) {
+            data = await store.get(hash);
+            if (data) {
+                data = await new globalThis.peernet.protos['peernet-data-response']({ hash, data });
+                const node = await this.prepareMessage(data);
+                this.sendMessage(peer, id, node.encoded);
+            }
+        }
+    }
+    async handleRequest(peer, id, proto) {
+        const method = this.requestProtos[proto.decoded.request];
+        if (method) {
+            const data = await method();
+            const node = await this.prepareMessage(data);
+            this.sendMessage(peer, id, node.encoded);
+        }
+    }
+    /**
+     * @private
+     *
+     * @param {Buffer} message - peernet message
+     * @param {PeernetPeer} peer - peernet peer
+     */
+    async _protoHandler(message, peer, from) {
+        const { id, proto } = message;
+        this.bw.down += proto.encoded.length;
+        switch (proto.name) {
+            case 'peernet-dht': {
+                this.handleDHT(peer, id, proto);
+                break;
+            }
+            case 'peernet-data': {
+                this.handleData(peer, id, proto);
+                break;
+            }
+            case 'peernet-request': {
+                this.handleRequest(peer, id, proto);
+            }
+            case 'peernet-ps': {
+                if (peer.peerId !== this.id)
+                    globalSub.publish(proto.decoded.topic, proto.decoded.data);
+            }
+        }
+    }
+    /**
+     * performs a walk and resolves first encounter
+     *
+     * @param {String} hash
+     */
+    async walk(hash) {
+        if (!hash)
+            throw new Error('hash expected, received undefined');
+        const data = await new globalThis.peernet.protos['peernet-dht']({ hash });
+        this.client.id;
+        const walk = async (peer) => {
+            const node = await this.prepareMessage(data);
+            let result = await peer.request(node.encoded);
+            result = new Uint8Array(Object.values(result));
+            const proto = await protoFor(result);
+            if (proto.name !== 'peernet-dht-response')
+                throw dhtError(proto.name);
+            // TODO: give ip and port (just used for location)
+            if (!peer.connection.remoteAddress || !peer.connection.localAddress) {
+                peer.connection.remoteFamily = 'ipv4';
+                peer.connection.remoteAddress = '127.0.0.1';
+                peer.connection.remotePort = '0000';
+            }
+            const peerInfo = {
+                family: peer.connection.remoteFamily || peer.connection.localFamily,
+                address: peer.connection.remoteAddress || peer.connection.localAddress,
+                port: peer.connection.remotePort || peer.connection.localPort,
+                id: peer.peerId,
+            };
+            if (proto.decoded.has)
+                this.dht.addProvider(peerInfo, proto.decoded.hash);
+        };
+        let walks = [];
+        for (const peer of this.connections) {
+            if (peer.peerId !== this.id) {
+                walks.push(walk(peer));
+            }
+        }
+        return Promise.all(walks);
+    }
+    /**
+     * Override DHT behavior, try's finding the content three times
+     *
+     * @param {String} hash
+     */
+    async providersFor(hash) {
+        let providers = await this.dht.providersFor(hash);
+        // walk the network to find a provider
+        if (!providers || providers.length === 0) {
+            await this.walk(hash);
+            providers = await this.dht.providersFor(hash);
+            // second walk the network to find a provider
+            if (!providers || providers.length === 0) {
+                await this.walk(hash);
+                providers = await this.dht.providersFor(hash);
+            }
+            // last walk
+            if (!providers || providers.length === 0) {
+                await this.walk(hash);
+                providers = await this.dht.providersFor(hash);
+            }
+        }
+        // undefined if no providers given
+        return providers;
+    }
+    get block() {
+        return {
+            get: async (hash) => {
+                const data = await blockStore.has(hash);
+                if (data)
+                    return blockStore.get(hash);
+                return this.requestData(hash, 'block');
+            },
+            put: async (hash, data) => {
+                if (await blockStore.has(hash))
+                    return;
+                return await blockStore.put(hash, data);
+            },
+            has: async (hash) => await blockStore.has(hash, 'block'),
+        };
+    }
+    get transaction() {
+        return {
+            get: async (hash) => {
+                const data = await transactionStore.has(hash);
+                if (data)
+                    return await transactionStore.get(hash);
+                return this.requestData(hash, 'transaction');
+            },
+            put: async (hash, data) => {
+                if (await transactionStore.has(hash))
+                    return;
+                return await transactionStore.put(hash, data);
+            },
+            has: async (hash) => await transactionStore.has(hash),
+        };
+    }
+    async requestData(hash, store) {
+        const providers = await this.providersFor(hash);
+        if (!providers || providers.size === 0)
+            throw nothingFoundError(hash);
+        debug(`found ${providers.size} provider(s) for ${hash}`);
+        // get closest peer on earth
+        const closestPeer = await this.dht.closestPeer(providers);
+        // get peer instance by id
+        if (!closestPeer || !closestPeer.id)
+            return this.requestData(hash, store?.name || store);
+        const id = closestPeer.id;
+        if (this.connections) {
+            let closest = this.connections.filter((peer) => {
+                if (peer.peerId === id)
+                    return peer;
+            });
+            let data = await new globalThis.peernet.protos['peernet-data']({ hash, store: store?.name || store });
+            const node = await this.prepareMessage(data);
+            if (closest[0])
+                data = await closest[0].request(node.encoded);
+            else {
+                closest = this.connections.filter((peer) => {
+                    if (peer.peerId === id)
+                        return peer;
+                });
+                if (closest[0])
+                    data = await closest[0].request(node.encoded);
+            }
+            const proto = await protoFor(data);
+            // TODO: store data automaticly or not
+            return BufferToUint8Array(proto.decoded.data);
+            // this.put(hash, proto.decoded.data)
+        }
+        return;
+    }
+    get message() {
+        return {
+            /**
+             * Get content for given message hash
+             *
+             * @param {String} hash
+             */
+            get: async (hash) => {
+                debug(`get message ${hash}`);
+                const message = await messageStore.has(hash);
+                if (message)
+                    return await messageStore.get(hash);
+                return this.requestData(hash, 'message');
+            },
+            /**
+             * put message content
+             *
+             * @param {String} hash
+             * @param {Buffer} message
+             */
+            put: async (hash, message) => await messageStore.put(hash, message),
+            /**
+             * @param {String} hash
+             * @return {Boolean}
+             */
+            has: async (hash) => await messageStore.has(hash),
+        };
+    }
+    get data() {
+        return {
+            /**
+             * Get content for given data hash
+             *
+             * @param {String} hash
+             */
+            get: async (hash) => {
+                debug(`get data ${hash}`);
+                const data = await dataStore.has(hash);
+                if (data)
+                    return await dataStore.get(hash);
+                return this.requestData(hash, 'data');
+            },
+            /**
+             * put data content
+             *
+             * @param {String} hash
+             * @param {Buffer} data
+             */
+            put: async (hash, data) => await dataStore.put(hash, data),
+            /**
+             * @param {String} hash
+             * @return {Boolean}
+             */
+            has: async (hash) => await dataStore.has(hash),
+        };
+    }
+    get folder() {
+        return {
+            /**
+             * Get content for given data hash
+             *
+             * @param {String} hash
+             */
+            get: async (hash) => {
+                debug(`get data ${hash}`);
+                const data = await dataStore.has(hash);
+                if (data)
+                    return await dataStore.get(hash);
+                return this.requestData(hash, 'data');
+            },
+            /**
+             * put data content
+             *
+             * @param {String} hash
+             * @param {Buffer} data
+             */
+            put: async (hash, data) => await dataStore.put(hash, data),
+            /**
+             * @param {String} hash
+             * @return {Boolean}
+             */
+            has: async (hash) => await dataStore.has(hash),
+        };
+    }
+    async addFolder(files) {
+        const links = [];
+        for (const file of files) {
+            const fileNode = await new globalThis.peernet.protos['peernet-file'](file);
+            const hash = await fileNode.hash;
+            await dataStore.put(hash, fileNode.encoded);
+            links.push({ hash, path: file.path });
+        }
+        const node = await new globalThis.peernet.protos['peernet-file']({ path: '/', links });
+        const hash = await node.hash;
+        await dataStore.put(hash, node.encoded);
+        return hash;
+    }
+    async ls(hash, options) {
+        let data;
+        const has = await dataStore.has(hash);
+        data = has ? await dataStore.get(hash) : await this.requestData(hash, 'data');
+        const node = await new peernet.protos['peernet-file'](data);
+        await node.decode();
+        console.log(data);
+        const paths = [];
+        if (node.decoded?.links.length === 0)
+            throw new Error(`${hash} is a file`);
+        for (const { path, hash } of node.decoded.links) {
+            paths.push({ path, hash });
+        }
+        if (options?.pin)
+            await dataStore.put(hash, node.encoded);
+        return paths;
+    }
+    async cat(hash, options) {
+        let data;
+        const has = await dataStore.has(hash);
+        data = has ? await dataStore.get(hash) : await this.requestData(hash, 'data');
+        const node = await new peernet.protos['peernet-file'](data);
+        if (node.decoded?.links.length > 0)
+            throw new Error(`${hash} is a directory`);
+        if (options?.pin)
+            await dataStore.put(hash, node.encoded);
+        return node.decoded.content;
+    }
+    /**
+     * goes trough given stores and tries to find data for given hash
+     * @param {Array} stores
+     * @param {string} hash
+     */
+    async whichStore(stores, hash) {
+        let store = stores.pop();
+        store = globalThis[`${store}Store`];
+        if (store) {
+            const has = await store.has(hash);
+            if (has)
+                return store;
+            if (stores.length > 0)
+                return this.whichStore(stores, hash);
+        }
+        else
+            return;
+    }
+    /**
+     * Get content for given hash
+     *
+     * @param {String} hash - the hash of the wanted data
+     * @param {String} store - storeName to access
+     */
+    async get(hash, store) {
+        debug(`get ${hash}`);
+        let data;
+        if (store)
+            store = globalThis[`${store}Store`];
+        if (!store)
+            store = await this.whichStore([...this.stores], hash);
+        if (store && await store.has(hash))
+            data = await store.get(hash);
+        if (data)
+            return data;
+        return this.requestData(hash, store?.name || store);
+    }
+    /**
+     * put content
+     *
+     * @param {String} hash
+     * @param {Buffer} data
+     * @param {String} store - storeName to access
+     */
+    async put(hash, data, store = 'data') {
+        store = globalThis[`${store}Store`];
+        return store.put(hash, data);
+    }
+    /**
+     * @param {String} hash
+     * @return {Boolean}
+     */
+    async has(hash) {
+        const store = await this.whichStore([...this.stores], hash);
+        if (store) {
+            return store.private ? false : true;
+        }
+        return false;
+    }
+    /**
+     *
+     * @param {String} topic
+     * @param {String|Object|Array|Boolean|Buffer} data
+     */
+    async publish(topic, data) {
+        // globalSub.publish(topic, data)
+        const id = Math.random().toString(36).slice(-12);
+        data = await new globalThis.peernet.protos['peernet-ps']({ data, topic });
+        for (const peer of this.connections) {
+            if (peer.peerId !== this.peerId) {
+                const node = await this.prepareMessage(data);
+                this.sendMessage(peer, id, node.encoded);
+            }
+            // TODO: if peer subscribed
+        }
+    }
+    createHash(data, name) {
+        return new CodeHash(data, { name });
+    }
+    /**
+     *
+     * @param {String} topic
+     * @param {Method} cb
+     */
+    async subscribe(topic, callback) {
+        // TODO: if peer subscribed
+        globalSub.subscribe(topic, callback);
+    }
+    async removePeer(peer) {
+        return this.client.removePeer(peer);
+    }
+    get Buffer() {
+        return Buffer;
+    }
+}
+globalThis.Peernet = Peernet;
 
-export { MultiWallet as default };
+export { FormatInterface as F, LittlePubSub as L, MultiWallet$1 as M, Peernet as P };