@leofcoin/peernet 1.1.50 → 1.1.52

package/exports/browser/{peernet-a4156bfd.js → peernet-bc021698.js}

@@ -1,4 +1,4 @@
-import { K as KeyValue } from './value-157ab062.js';
+import { K as KeyPath, a as KeyValue } from './value-4e80eeeb.js';
 
 if (!globalThis.DEBUG) {
   if (globalThis.localStorage) globalThis.DEBUG = Boolean(globalThis.localStorage.getItem('DEBUG') === 'true');
@@ -206,16 +206,16 @@ 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 decode$8 = base32.decode;
 const decodeHex$2 = base32Hex.decode;
-const encode$8 = base32.encode;
+const encode$7 = base32.encode;
 const encodeHex$2 = base32Hex.encode;
 const isBase32 = (string, hex = false) => {
     try {
         if (hex)
             decodeHex$2(string);
         else
-            decode$9(string);
+            decode$8(string);
         return true;
     }
     catch (e) {
@@ -226,8 +226,8 @@ const isBase32Hex = (string) => {
     return isBase32(string, true);
 };
 var index$8 = {
-    encode: encode$8,
-    decode: decode$9,
+    encode: encode$7,
+    decode: decode$8,
     encodeHex: encodeHex$2,
     decodeHex: decodeHex$2,
     isBase32,
@@ -238,13 +238,13 @@ 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 encode$6 = base58.encode;
+var decode$7 = base58.decode;
 var encodeHex$1 = base58Hex.encode;
 var decodeHex$1 = base58Hex.decode;
 var isBase58 = function (string) {
     try {
-        decode$8(string);
+        decode$7(string);
         return true;
     }
     catch (e) {
@@ -262,7 +262,7 @@ var isBase58Hex = function (string) {
 };
 var whatType = function (string) {
     try {
-        decode$8(string);
+        decode$7(string);
         return 'base58';
     }
     catch (e) {
@@ -275,15 +275,15 @@ var whatType = function (string) {
         }
     }
 };
-var base58$1 = { encode: encode$7, decode: decode$8, isBase58: isBase58, isBase58Hex: isBase58Hex, encodeHex: encodeHex$1, decodeHex: decodeHex$1, whatType: whatType };
+var base58$1 = { encode: encode$6, decode: decode$7, 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) => {
+const encode$5 = (num, out, offset) => {
     if (Number.MAX_SAFE_INTEGER && num > Number.MAX_SAFE_INTEGER) {
-        encode$6.bytes = 0;
+        encode$5.bytes = 0;
         throw new RangeError('Could not encode varint');
     }
     out = out || [];
@@ -298,13 +298,13 @@ const encode$6 = (num, out, offset) => {
         num >>>= 7;
     }
     out[offset] = num | 0;
-    encode$6.bytes = offset - oldOffset + 1;
+    encode$5.bytes = offset - oldOffset + 1;
     return out;
 };
 
 const MSB = 0x80;
 const REST = 0x7F;
-const decode$7 = (buf, offset) => {
+const decode$6 = (buf, offset) => {
     offset = offset || 0;
     const l = buf.length;
     let counter = offset;
@@ -313,7 +313,7 @@ const decode$7 = (buf, offset) => {
     let b;
     do {
         if (counter >= l || shift > 49) {
-            decode$7.bytes = 0;
+            decode$6.bytes = 0;
             throw new RangeError('Could not decode varint');
         }
         b = buf[counter++];
@@ -322,7 +322,7 @@ const decode$7 = (buf, offset) => {
             : (b & REST) * Math.pow(2, shift);
         shift += 7;
     } while (b >= MSB);
-    decode$7.bytes = counter - offset;
+    decode$6.bytes = counter - offset;
     return result;
 };
 
@@ -347,8 +347,8 @@ var encodingLength = (value) => (value < N1 ? 1
                                     : 10);
 
 var index$7 = {
-    encode: encode$6,
-    decode: decode$7,
+    encode: encode$5,
+    decode: decode$6,
     encodingLength
 };
 
@@ -398,11 +398,11 @@ var index$5 = (typedArray, prefix) => {
 
 const ALPHABET$1 = '0123456789ABCDEF';
 const base16 = base$1(ALPHABET$1);
-const decode$6 = base16.decode;
-const encode$5 = base16.encode;
+const decode$5 = base16.decode;
+const encode$4 = base16.encode;
 const isBase16 = (string) => {
     try {
-        decode$6(string);
+        decode$5(string);
         return true;
     }
     catch (e) {
@@ -410,18 +410,18 @@ const isBase16 = (string) => {
     }
 };
 var index$4 = {
-    encode: encode$5,
-    decode: decode$6,
+    encode: encode$4,
+    decode: decode$5,
     isBase16
 };
 
 const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
 const base64 = base$1(ALPHABET);
-const decode$5 = base64.decode;
-const encode$4 = base64.encode;
+const decode$4 = base64.decode;
+const encode$3 = base64.encode;
 const isBase64 = (string) => {
     try {
-        decode$5(string);
+        decode$4(string);
         return true;
     }
     catch (e) {
@@ -429,221 +429,211 @@ const isBase64 = (string) => {
     }
 };
 var index$3 = {
-    encode: encode$4,
-    decode: decode$5,
+    encode: encode$3,
+    decode: decode$4,
     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$2 = (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$3.encode(uint8Array);
-const fromBase64 = (string) => index$3.decode(string);
-const toBase58 = (uint8Array) => base58$1.encode(uint8Array);
-const fromBase58 = (string) => base58$1.decode(string);
-const toBase32 = (uint8Array) => index$8.encode(uint8Array);
-const fromBase32 = (string) => index$8.decode(string);
-const toBase16 = (uint8Array) => index$4.encode(uint8Array);
-const fromBase16 = (string) => index$4.decode(string);
-let FormatInterface$2 = class FormatInterface {
-    encoded;
-    constructor(input) {
-        if (input) {
-            if (index$4.isBase16(input))
-                this.encoded = this.fromBase16(input);
-            else if (index$8.isBase32(input))
-                this.encoded = this.fromBase32(input);
-            else if (base58$1.isBase58(input))
-                this.encoded = this.fromBase58(input);
-            else if (index$3.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$3.encode(uint8Array);
-    }
-    fromBase64(string) {
-        return index$3.decode(string);
-    }
-    toBase58(uint8Array) {
-        return base58$1.encode(uint8Array);
-    }
-    fromBase58(string) {
-        return base58$1.decode(string);
-    }
-    toBase32(uint8Array) {
-        return index$8.encode(uint8Array);
-    }
-    fromBase32(string) {
-        return index$8.decode(string);
-    }
-    toBase16(uint8Array) {
-        return index$4.encode(uint8Array);
-    }
-    fromBase16(string) {
-        return index$4.decode(string);
-    }
-};
-var index$2 = {
-    fromString: fromString$1,
-    toString: toString$1,
-    fromHex,
-    toHex: toHex$2,
-    fromArrayLike,
-    toArrayLike,
-    fromUintArrayString,
-    toUintArrayString,
-    toBase64,
-    fromBase64,
-    toBase58,
-    fromBase58,
-    toBase32,
-    fromBase32,
-    toBase16,
-    fromBase16,
-    FormatInterface: FormatInterface$2
+/**
+ * Returns a hex string as Binary string
+ * @param string string to encode to binary
+ * @returns binaryString
+ */
+const hexToBinary = (hex) => (parseInt(hex, 16).toString(2)).padStart(8, '0');
+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$2 = (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()];
+/**
+* object -> Uint8Array
+* @param object any
+* @returns Uint8Array
+*/
+const fromObject = (object) => new TextEncoder().encode(JSON.stringify(object));
+/**
+ * Uint8Array -> Object
+ * @param uint8Array Uint8Array
+ * @returns Object
+ */
+const toObject = (uint8Array) => JSON.parse(new TextDecoder().decode(uint8Array));
+const fromBinary = (string) => fromHex(parseInt(string, 2).toString(16).toUpperCase());
+const toBinary = (uint8Array) => hexToBinary(toHex$2(uint8Array));
+const toBase64 = (uint8Array) => index$3.encode(uint8Array);
+const fromBase64 = (string) => index$3.decode(string);
+const toBase58 = (uint8Array) => base58$1.encode(uint8Array);
+const fromBase58 = (string) => base58$1.decode(string);
+const toBase32 = (uint8Array) => index$8.encode(uint8Array);
+const fromBase32 = (string) => index$8.decode(string);
+const toBase16 = (uint8Array) => index$4.encode(uint8Array);
+const fromBase16 = (string) => index$4.decode(string);
+let FormatInterface$2 = class FormatInterface {
+    encoded;
+    decoded;
+    constructor(input) {
+        if (input) {
+            if (index$4.isBase16(input))
+                this.encoded = this.fromBase16(input);
+            else if (index$8.isBase32(input))
+                this.encoded = this.fromBase32(input);
+            else if (base58$1.isBase58(input))
+                this.encoded = this.fromBase58(input);
+            else if (index$3.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) => this.encoded = fromString$1(string);
+    /**
+     * Returns a Uint8Array as String
+     * @param uint8Array Uint8Array to encode to String
+     * @returns String
+     */
+    toString = (uint8Array) => this.decoded = toString$1(uint8Array);
+    /**
+     * Returns a String as Uint8Array
+     * @param string string to encode to Uint8Array
+     * @returns Uint8Array
+     */
+    fromUintArrayString = (string) => this.encoded = fromUintArrayString(string);
+    /**
+     * Returns a Uint8Array as String
+     * @param uint8Array Uint8Array to encode to String
+     * @returns String
+     */
+    toUintArrayString = (uint8Array) => this.decoded = uint8Array.toString();
+    /**
+     * hexString -> uint8Array
+     * @param string hex encoded string
+     * @returns UintArray
+     */
+    fromHex = (string) => this.encoded = fromHex(string);
+    /**
+     * uint8Array -> hexString
+     * @param bytes ArrayLike
+     * @returns hexString
+     */
+    toHex = (arrayLike) => this.decoded = toHex$2(arrayLike);
+    /**
+     * number[] -> Uint8Array
+     * @param array number[]
+     * @returns Uint8Array
+     */
+    fromArrayLike = (array) => this.encoded = Uint8Array.from(array);
+    /**
+     * Uint8Array -> number[]
+     * @param uint8Array Uint8Array
+     * @returns Uint8Array
+     */
+    toArrayLike = (uint8Array) => this.decoded = [...uint8Array.values()];
+    fromObject = (object) => this.encoded = fromObject(object);
+    toBinary = (uint8Array) => this.decoded = hexToBinary(toHex$2(uint8Array));
+    fromBinary = (binary) => this.encoded = fromBinary(binary);
+    toObject = (uint8Array) => this.decoded = toObject(uint8Array);
+    toBase64 = (uint8Array) => this.decoded = index$3.encode(uint8Array);
+    fromBase64 = (string) => this.encoded = index$3.decode(string);
+    toBase58 = (uint8Array) => this.decoded = base58$1.encode(uint8Array);
+    fromBase58 = (string) => this.encoded = base58$1.decode(string);
+    toBase32 = (uint8Array) => this.decoded = index$8.encode(uint8Array);
+    fromBase32 = (string) => this.encoded = index$8.decode(string);
+    toBase16 = (uint8Array) => this.decoded = index$4.encode(uint8Array);
+    fromBase16 = (string) => this.decoded = index$4.decode(string);
+};
+var index$2 = {
+    fromString: fromString$1,
+    toString: toString$1,
+    fromHex,
+    toHex: toHex$2,
+    fromArrayLike,
+    toArrayLike,
+    fromUintArrayString,
+    toUintArrayString,
+    toObject,
+    toBinary,
+    fromBinary,
+    toBase64,
+    fromBase64,
+    toBase58,
+    fromBase58,
+    toBase32,
+    fromBase32,
+    toBase16,
+    fromBase16,
+    FormatInterface: FormatInterface$2
 };
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
@@ -4816,7 +4806,7 @@ const toType = (data) => {
         return new TextEncoder().encode(data.toString());
     throw new Error(`unsuported type ${typeof data || data}`);
 };
-const encode$3 = (proto, input, compress) => {
+const encode$2 = (proto, input, compress) => {
     const keys = Object.keys(proto);
     const values = Object.values(proto);
     const set = [];
@@ -4833,7 +4823,7 @@ const encode$3 = (proto, input, compress) => {
     }
     return index$6(set);
 };
-const decode$4 = (proto, uint8Array, compressed) => {
+const decode$3 = (proto, uint8Array, compressed) => {
     let deconcated = index$5(uint8Array);
     const output = {};
     const keys = Object.keys(proto);
@@ -4864,8 +4854,8 @@ const decode$4 = (proto, uint8Array, compressed) => {
     return output;
 };
 var index$1 = {
-    encode: encode$3,
-    decode: decode$4
+    encode: encode$2,
+    decode: decode$3
 };
 
 /*!
@@ -6235,8 +6225,7 @@ class DhtEarth {
         if (!fetchedCoordinates[address]) {
             const request = `https://whereis.leofcoin.org/?ip=${address}`;
             let response = await fetch(request);
-            response = await response.json();
-            const { lat, lon } = response;
+            const { lat, lon } = await response.json();
             fetchedCoordinates[address] = { latitude: lat, longitude: lon };
         }
         return fetchedCoordinates[address];
@@ -6260,6 +6249,7 @@ class DhtEarth {
             else
                 all.push(this.getDistance(peerLoc, provider));
         }
+        // todo queue
         all = await Promise.all(all);
         all = all.sort((previous, current) => previous.distance - current.distance);
         return all[0].provider;
@@ -6273,22 +6263,20 @@ class DhtEarth {
             providers = this.providerMap.get(hash);
         return providers;
     }
-    addProvider(address, hash) {
-        let providers = new Set();
+    addProvider(provider, hash) {
+        let providers = {};
         if (this.providerMap.has(hash)) {
             providers = this.providerMap.get(hash);
         }
-        providers.add(address);
+        providers[provider.address] = provider;
         this.providerMap.set(hash, providers);
     }
     removeProvider(address, hash) {
-        let deleted = undefined;
         if (this.providerMap.has(hash)) {
             const providers = this.providerMap.get(hash);
-            deleted = providers.delete(address);
-            deleted && this.providerMap.set(hash, providers);
+            delete providers[address];
+            this.providerMap.set(hash, providers);
         }
-        return deleted;
     }
 }
 
@@ -6344,278 +6332,188 @@ 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)
-  }
-
-}
-
 let LeofcoinStorage$1 = class LeofcoinStorage {
+    name;
+    root;
+    db;
+    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();
+    }
+};
 
-  constructor(name = 'storage', root = '.leofcoin') {
-    this.name = name;
-    this.root = root;
-  }
+const randombytes = strength => crypto.getRandomValues(new Uint8Array(strength));
 
-  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);
-  }
+const {subtle} = crypto;
 
-  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));
-  }
+/**
+ * ```js
+ * const {createHash} = await import('@leofcoin/crypto')
+ * createHash(data, algorithm)
+ * ```
+ * @param {Uint8Array} data 
+ * @param {string} algorithm 
+ * @returns Uint8Array
+ */
+const createHash = (data, algorithm = 'SHA-512') => subtle.digest(algorithm, data);
 
-  async has(key) {
-    if (typeof key === 'object') return this.many('has', key);
+/**
+ * Hashes the created hash again
+ * ```js
+ * const {createDoubleHash} = await import('@leofcoin/crypto')
+ * createDoubleHash(data, algorithm)
+ * ```
+ * @param {Uint8Array} data 
+ * @param {string} algorithm 
+ * @returns Uint8Array
+ */
+const createDoubleHash = async (data, algorithm = 'SHA-512') =>
+  subtle.digest(algorithm, await subtle.digest(algorithm, data));
 
-    try {
-      const has = await this.db.get(new KeyPath(key));
+const generatePbkdf2 = async (password) => {  
+  return subtle.importKey(
+    'raw',
+    password,
+    'PBKDF2',
+    false,
+    ['deriveBits']
+  )  
+};
 
-      return Boolean(has);
-    } catch (e) {
-      return false
-    }
-  }
+const pbkdf2 = async (password, salt, iterations = 4096, length = 64, hash = 'SHA-512') => {
+  const key = await generatePbkdf2(password);
+  return subtle.deriveBits({
+    name: 'PBKDF2',
+    hash,
+    salt,
+    iterations,
+  }, key, length)
+};
 
-  async delete(key) {
-    return this.db.delete(new KeyPath(key))
-  }
+const generateAesKey = async (length = 256) => {
+  const key = await subtle.generateKey({
+    name: 'AES-CBC',
+    length
+  }, true, ['encrypt', 'decrypt']);
 
-  keys(limit = -1) {
-    return this.db.keys(limit)
-  }
+  return key;
+};
 
-  async values(limit = -1) {
-    return this.db.values(limit)
-  }
+const importAesKey = async (exported, format = 'raw', length = 256) => {
+  return await subtle.importKey(format, exported, {
+    name: 'AES-CBC',
+    length
+  }, true, ['encrypt', 'decrypt'])
+};
 
-  async many(type, _value) {
-    const jobs = [];
+const exportAesKey = async (key, format = 'raw') => {
+  return await subtle.exportKey(format, key)
+};
 
-    for (const key of Object.keys(_value)) {
-      jobs.push(this[type](key, _value[key]));
-    }
+const encryptAes = async (uint8Array, key, iv) => subtle.encrypt({
+    name: 'AES-CBC',
+    iv,
+  }, key, uint8Array);
 
-    return Promise.all(jobs)
-  }
+const decryptAes = async (uint8Array, key, iv) => subtle.decrypt({
+    name: 'AES-CBC',
+    iv,
+  }, key, uint8Array);
 
-  async length() {
-    const keys = await this.keys();
-    return keys.length
-  }
+const uint8ArrayToHex = uint8Array =>
+  [...uint8Array].map(x => x.toString(16).padStart(2, '0')).join('');
 
-  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
-  }
+const arrayBufferToHex = arrayBuffer =>
+  uint8ArrayToHex(new Uint8Array(arrayBuffer));
 
-  async clear() {
-    return this.db.clear()
-  }
+const hexToUint8Array = hex =>
+  new Uint8Array(hex.match(/[\da-f]{2}/gi).map(x => parseInt(x, 16)));
 
-  async iterate() {
-    return this.db.iterate()
+const encrypt$1 = async string => {
+  const key = await generateAesKey();
+  const iv = randombytes(16);
+  const ciphertext = await encryptAes(new TextEncoder().encode(string), key, iv);
+  const exported = await exportAesKey(key);
+  return {
+    key: arrayBufferToHex(exported),
+    iv: uint8ArrayToHex(iv),
+    cipher: arrayBufferToHex(ciphertext)
   }
-
 };
 
-const randombytes = strength => crypto.getRandomValues(new Uint8Array(strength));
-
-const {subtle} = crypto;
-
-/**
- * ```js
- * const {createHash} = await import('@leofcoin/crypto')
- * createHash(data, algorithm)
- * ```
- * @param {Uint8Array} data 
- * @param {string} algorithm 
- * @returns Uint8Array
- */
-const createHash = (data, algorithm = 'SHA-512') => subtle.digest(algorithm, data);
+const decrypt$1 = async ({cipher, key, iv}) => {
+  if (!key.type) key = await importAesKey(hexToUint8Array(key));
+  cipher = new Uint8Array(hexToUint8Array(cipher));
+  iv = new Uint8Array(hexToUint8Array(iv));
 
-/**
- * Hashes the created hash again
- * ```js
- * const {createDoubleHash} = await import('@leofcoin/crypto')
- * createDoubleHash(data, algorithm)
- * ```
- * @param {Uint8Array} data 
- * @param {string} algorithm 
- * @returns Uint8Array
- */
-const createDoubleHash = async (data, algorithm = 'SHA-512') =>
-  subtle.digest(algorithm, await subtle.digest(algorithm, data));
-
-const generatePbkdf2 = async (password) => {  
-  return subtle.importKey(
-    'raw',
-    password,
-    'PBKDF2',
-    false,
-    ['deriveBits']
-  )  
-};
-
-const pbkdf2 = async (password, salt, iterations = 4096, length = 64, hash = 'SHA-512') => {
-  const key = await generatePbkdf2(password);
-  return subtle.deriveBits({
-    name: 'PBKDF2',
-    hash,
-    salt,
-    iterations,
-  }, key, length)
-};
-
-const generateAesKey = async (length = 256) => {
-  const key = await subtle.generateKey({
-    name: 'AES-CBC',
-    length
-  }, true, ['encrypt', 'decrypt']);
-
-  return key;
-};
-
-const importAesKey = async (exported, format = 'raw', length = 256) => {
-  return await subtle.importKey(format, exported, {
-    name: 'AES-CBC',
-    length
-  }, true, ['encrypt', 'decrypt'])
-};
-
-const exportAesKey = async (key, format = 'raw') => {
-  return await subtle.exportKey(format, key)
-};
-
-const encryptAes = async (uint8Array, key, iv) => subtle.encrypt({
-    name: 'AES-CBC',
-    iv,
-  }, key, uint8Array);
-
-const decryptAes = async (uint8Array, key, iv) => subtle.decrypt({
-    name: 'AES-CBC',
-    iv,
-  }, key, uint8Array);
-
-const uint8ArrayToHex = uint8Array =>
-  [...uint8Array].map(x => x.toString(16).padStart(2, '0')).join('');
-
-const arrayBufferToHex = arrayBuffer =>
-  uint8ArrayToHex(new Uint8Array(arrayBuffer));
-
-const hexToUint8Array = hex =>
-  new Uint8Array(hex.match(/[\da-f]{2}/gi).map(x => parseInt(x, 16)));
-
-const encrypt$1 = async string => {
-  const key = await generateAesKey();
-  const iv = randombytes(16);
-  const ciphertext = await encryptAes(new TextEncoder().encode(string), key, iv);
-  const exported = await exportAesKey(key);
-  return {
-    key: arrayBufferToHex(exported),
-    iv: uint8ArrayToHex(iv),
-    cipher: arrayBufferToHex(ciphertext)
-  }
-};
-
-const decrypt$1 = async ({cipher, key, iv}) => {
-  if (!key.type) key = await importAesKey(hexToUint8Array(key));
-  cipher = new Uint8Array(hexToUint8Array(cipher));
-  iv = new Uint8Array(hexToUint8Array(iv));
-
-  const plaintext = await decryptAes(cipher, key, iv);
-  return new TextDecoder().decode(plaintext);
+  const plaintext = await decryptAes(cipher, key, iv);
+  return new TextDecoder().decode(plaintext);
 };
 
 var typedArrayConcat = (input, options = {length: undefined, seperator: undefined}) => {
@@ -20180,7 +20078,7 @@ class Identity {
             globalThis.peernet.selectedAccount = new TextDecoder().decode(selected);
         }
         else {
-            const importee = await import(/* webpackChunkName: "generate-account" */ './index-6311966e.js');
+            const importee = await import(/* webpackChunkName: "generate-account" */ './index-5f552dff.js');
             const { identity, accounts } = await importee.default(password, this.network);
             await globalThis.accountStore.put('public', JSON.stringify({ walletId: identity.walletId }));
             await globalThis.walletStore.put('version', String(1));
@@ -20228,8 +20126,11 @@ globalThis.globalSub = globalThis.globalSub || new LittlePubSub();
  * const peernet = new Peernet();
  */
 class Peernet {
+    storePrefix;
+    root;
     identity;
     stores = [];
+    peerId;
     /**
      * @type {Object}
      * @property {Object} peer Instance of Peer
@@ -20248,6 +20149,7 @@ class Peernet {
     #connections = {};
     requestProtos = {};
     _messageHandler;
+    _peerHandler;
     protos;
     /**
      * @access public
@@ -20283,6 +20185,7 @@ class Peernet {
             up: 0,
             down: 0,
         };
+        // @ts-ignore
         return this._init(options, password);
     }
     get id() {
@@ -20354,7 +20257,7 @@ class Peernet {
         this.root = options.root;
         const { RequestMessage, ResponseMessage, PeerMessage, PeerMessageResponse, PeernetMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PsMessage, ChatMessage, PeernetFile
         // FolderMessageResponse
-         } = await import(/* webpackChunkName: "messages" */ './messages-54aa3cad.js');
+         } = await import(/* webpackChunkName: "messages" */ './messages-0591b744.js');
         /**
          * proto Object containing protos
          * @type {Object}
@@ -20421,7 +20324,13 @@ class Peernet {
         else {
             process.on('SIGTERM', async () => {
                 process.stdin.resume();
-                await this.client.destroy();
+                try {
+                    await this.client.destroy();
+                }
+                catch (error) {
+                    // @ts-ignore
+                    await this.client.close();
+                }
                 process.exit();
             });
         }
@@ -20433,7 +20342,7 @@ class Peernet {
         if (this.#starting || this.#started)
             return;
         this.#starting = true;
-        const importee = await import('./client-6072af1a.js');
+        const importee = await import('./client-3221a5d7.js');
         /**
          * @access public
          * @type {PeernetClient}
@@ -20561,21 +20470,13 @@ class Peernet {
      * @param {String} hash
      */
     async providersFor(hash, store) {
-        let providers = await this.dht.providersFor(hash);
+        let providers = this.dht.providersFor(hash);
         // walk the network to find a provider
-        if (!providers || providers.length === 0) {
+        let tries = 0;
+        while (!providers && tries < 3 || Object.keys(providers).length === 0 && tries < 3) {
+            tries += 1;
             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);
-            }
+            providers = this.dht.providersFor(hash);
         }
         // undefined if no providers given
         return providers;
@@ -20614,11 +20515,11 @@ class Peernet {
     }
     async requestData(hash, store) {
         const providers = await this.providersFor(hash);
-        if (!providers || providers.size === 0)
+        if (!providers || Object.keys(providers).length === 0)
             throw nothingFoundError(hash);
         debug(`found ${providers.size} provider(s) for ${hash}`);
         // get closest peer on earth
-        const closestPeer = Array.from(providers)[0];
+        const closestPeer = Object.values(providers)[0];
         // get peer instance by id
         if (!closestPeer || !closestPeer.id)
             return this.requestData(hash, store?.name || store);
@@ -20633,7 +20534,7 @@ class Peernet {
                 // fallback and try every provider found
                 const promises = [];
                 const providers = await this.providersFor(hash, store);
-                for (const provider of providers) {
+                for (const provider of Object.values(providers)) {
                     const peer = this.#connections[provider.id];
                     if (peer)
                         promises.push(peer.request(node.encoded));
@@ -20819,10 +20720,10 @@ class Peernet {
      *
      * @param {String} hash
      * @param {Buffer} data
-     * @param {String} store - storeName to access
+     * @param {String} storeName - storeName to access
      */
-    async put(hash, data, store = 'data') {
-        store = globalThis[`${store}Store`];
+    async put(hash, data, storeName = 'data') {
+        const store = globalThis[`${storeName}Store`];
         return store.put(hash, data);
     }
     /**
@@ -20853,9 +20754,9 @@ class Peernet {
             // TODO: if peer subscribed
         }
     }
-    createHash(data, name) {
-        return new CodeHash(data, { name });
-    }
+    // createHash(data, name) {
+    //   return new CodeHash(data, {name})
+    // }
     /**
      *
      * @param {String} topic
@@ -20869,10 +20770,10 @@ class Peernet {
         console.log('removepeer', peer.id);
         const id = peer.id;
         await this.client._removePeer(peer);
-        console.log(this.client.peers[id]);
         if (this.client.peers[id]) {
             for (const connection of Object.keys(this.client.peers[id])) {
-                // if (this.client.peers[id][connection].connected === false) delete this.client.peers[id][connection] 
+                // if (this.client.peers[id][connection].connected === false) delete this.client.peers[id][connection]
+                // @ts-ignore
                 if (this.client.peers[id][connection].connected)
                     return this.client.emit('peerconnect', connection);
             }