@leofcoin/peernet 1.1.45 → 1.1.47

package/exports/browser/{peernet-bdde86d9.js → peernet-20a06ecc.js}

@@ -1,5 +1,3 @@
-import { K as KeyValue } from './value-157ab062.js';
-
 if (!globalThis.DEBUG) {
   if (globalThis.localStorage) globalThis.DEBUG = Boolean(globalThis.localStorage.getItem('DEBUG') === 'true');
 }
@@ -8,55 +6,55 @@ 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);
-        });
-    }
+class LittlePubSub {
+    subscribers = {};
+    verbose;
+    constructor(verbose) {
+        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
@@ -206,16 +204,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 +224,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 +236,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 +260,7 @@ var isBase58Hex = function (string) {
 };
 var whatType = function (string) {
     try {
-        decode$8(string);
+        decode$7(string);
         return 'base58';
     }
     catch (e) {
@@ -275,15 +273,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 +296,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 +311,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 +320,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 +345,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 +396,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 +408,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,8 +427,8 @@ const isBase64 = (string) => {
     }
 };
 var index$3 = {
-    encode: encode$4,
-    decode: decode$5,
+    encode: encode$3,
+    decode: decode$4,
     isBase64
 };
 
@@ -691,6 +689,8 @@ var _nodeResolve_empty$1 = /*#__PURE__*/Object.freeze({
 
 var require$$0$1 = /*@__PURE__*/getAugmentedNamespace(_nodeResolve_empty$1);
 
+bn$1.exports;
+
 (function (module) {
 	(function (module, exports) {
 
@@ -4814,7 +4814,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 = [];
@@ -4831,7 +4831,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);
@@ -4862,8 +4862,8 @@ const decode$4 = (proto, uint8Array, compressed) => {
     return output;
 };
 var index$1 = {
-    encode: encode$3,
-    decode: decode$4
+    encode: encode$2,
+    decode: decode$3
 };
 
 /*!
@@ -6046,55 +6046,54 @@ const FormatInterface = FormatInterface$1;
 const Codec = Codec$1;
 
 const BufferToUint8Array = data => {
-    if (data.type === 'Buffer') {
-        data = new Uint8Array(data.data);
-    }
-    return 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);
+  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;
-    }
+  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:');
+  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';
-    }
+  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
@@ -6102,84 +6101,84 @@ const environment = () => {
  * @property {Boolean} reult.environment Current environment
  */
 const target = async () => {
-    let daemon = false;
-    if (!https())
-        daemon = await hasDaemon();
-    return { daemon, environment: environment() };
+  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];
-            }
-        }
+  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 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);
+      }
     }
-    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 })));
+    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);
         }
-        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);
-                }
-            }
+      }
+      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);
         }
+      }
     }
+  }
 }
 
 /**
@@ -6292,219 +6291,56 @@ class DhtEarth {
 }
 
 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) {
-        const hash = await message.peernetHash;
-        message.decoded.signature = globalThis.identity.sign(hash.buffer);
-        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, peer } = message;
-    const proto = await protoFor(data);
-    peernet._protoHandler({ id, proto }, peernet.connections[from] || peer, 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)
+  constructor(network) {
+    this.network = network;
   }
-
   /**
-   * Returns the `list` representation of this path.
+   * hash and sign message
    *
-   * @returns string[]
-   *
-   * @example
-   * ```js
-   * new Key('/Comedy/MontyPython/Actor:JohnCleese').list()
-   * // => ['Comedy', 'MontyPythong', 'Actor:JohnCleese']
-   * ```
+   * @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
    */
-  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 hashAndSignMessage(message) {
+    const hash = await message.peernetHash;
+    message.decoded.signature = globalThis.identity.sign(hash.buffer);
+    return message
   }
 
-  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
+   * @param {String} from - peer id
+   * @param {String} to - peer id
+   * @param {String|PeernetMessage} data - data encoded message string
+   * or the messageNode itself
    */
-  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]));
+  async prepareMessage(message) {    
+    if (message.keys.includes('signature')) {
+      message = await this.hashAndSignMessage(message);
     }
 
-    return Promise.all(jobs)
+    return message
   }
+}
 
-  async length() {
-    const keys = await this.keys();
-    return keys.length
-  }
+const dataHandler = async message => {
+  if (!message) return
 
-  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()
-  }
+  const {data, id, from, peer} = message;
+  const proto = await protoFor(data);
+  peernet._protoHandler({id, proto}, peernet.connections[from] || peer, from);
+};
 
-  async iterate() {
-    return this.db.iterate()
-  }
+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}`)
+};
 
 const randombytes = strength => crypto.getRandomValues(new Uint8Array(strength));
 
@@ -7149,6 +6985,8 @@ var utils$o = {};
 
 var bn = {exports: {}};
 
+bn.exports;
+
 (function (module) {
 	(function (module, exports) {
 
@@ -20174,7 +20012,7 @@ class Identity {
             globalThis.peernet.selectedAccount = new TextDecoder().decode(selected);
         }
         else {
-            const importee = await import(/* webpackChunkName: "generate-account" */ './index-502d190c.js');
+            const importee = await import(/* webpackChunkName: "generate-account" */ './index-96b718dc.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));
@@ -20214,8 +20052,8 @@ class Identity {
 
 globalThis.LeofcoinStorage = LeofcoinStorage;
 globalThis.leofcoin = globalThis.leofcoin || {};
-globalThis.pubsub = globalThis.pubsub || new LittlePubSub();
-globalThis.globalSub = globalThis.globalSub || new LittlePubSub();
+pubsub = pubsub || new LittlePubSub();
+globalSub = globalSub || new LittlePubSub();
 /**
  * @access public
  * @example
@@ -20235,11 +20073,14 @@ class Peernet {
     stars;
     networkVersion;
     bw;
+    hasDaemon = false;
     autoStart = true;
     #starting = false;
     #started = false;
     #connections = {};
     requestProtos = {};
+    _messageHandler;
+    protos;
     /**
      * @access public
      * @param {Object} options
@@ -20269,7 +20110,7 @@ class Peernet {
         if (!options.root) {
             parts[1] ? options.root = `.${parts[0]}/${parts[1]}` : options.root = `.${this.network}`;
         }
-        globalThis.peernet = this;
+        peernet = this;
         this.bw = {
             up: 0,
             down: 0,
@@ -20345,7 +20186,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-cd01524c.js');
+         } = await import(/* webpackChunkName: "messages" */ './messages-591e0b2c.js');
         /**
          * proto Object containing protos
          * @type {Object}