@leofcoin/peernet 0.18.0 → 0.18.2

package/exports/browser/{peernet-24ed8563.js → peernet-2796cdb2.js}

@@ -1258,6 +1258,187 @@ 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.peernet = globalThis.peernet || {};
+globalThis.peernet.codecs = globalThis.peernet.codecs || {};
+const addCodec = (codecInput) => {
+    let { hashAlg, codec, name } = codecInput;
+    if (!globalThis.peernet.codecs[name])
+        globalThis.peernet.codecs[name] = {
+            hashAlg,
+            codec: parseInt(codec, 16)
+        };
+};
+const getCodec = (name) => globalThis.peernet.codecs[name];
+const getCodecName = (codec) => {
+    return Object.keys(globalThis.peernet.codecs).reduce((p, c) => {
+        const item = globalThis.peernet.codecs[c];
+        if (item.codec === codec)
+            return c;
+        else
+            return p;
+    }, undefined);
+};
+const getCodecByName = (name) => globalThis.peernet.codecs[name];
+const getHashAlg = (name) => {
+    if (typeof name === 'number')
+        return getCodecByName(getCodecName(name)).hashAlg;
+    return getCodecByName(name).hashAlg;
+};
+const isCodec = (codec) => {
+    if (codec.codec !== undefined && codec.hashAlg)
+        return true;
+    return false;
+};
+const validateCodec = (codec) => {
+    if (codec.codec === undefined ||
+        codec.hashAlg === undefined ||
+        codec.name === undefined)
+        throw new Error(`invalid codecInput: ${codec}`);
+};
+for (const codec of codecs) {
+    addCodec(codec);
+}
+var utils = {
+    isCodec,
+    addCodec,
+    getCodec,
+    getHashAlg,
+    getCodecName,
+    validateCodec,
+    codecs: globalThis.peernet.codecs
+};
+
 /**
  * @param {string}
  */
@@ -1268,6 +1449,22 @@ let BasicInterface$1 = class BasicInterface {
     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
@@ -1287,12 +1484,10 @@ let BasicInterface$1 = class BasicInterface {
         return base58$1.isBase58(string);
     }
     fromBs32(encoded) {
-        this.encoded = index$7.decode(encoded);
-        return this.decode();
+        return this.decode(index$7.decode(encoded));
     }
     fromBs58(encoded) {
-        this.encoded = fromBase58(encoded);
-        return this.decode();
+        return this.decode(fromBase58(encoded));
     }
     async toArray() {
         const array = [];
@@ -1304,20 +1499,16 @@ let BasicInterface$1 = class BasicInterface {
     fromString(string) {
         const array = string.split(',');
         const arrayLike = array.map(string => Number(string));
-        this.encoded = Uint8Array.from(arrayLike);
-        return this.decode();
+        return this.decode(Uint8Array.from(arrayLike));
     }
     fromHex(string) {
-        this.encoded = fromHex(string);
-        return this.decode();
+        return this.decode(fromHex(string));
     }
     fromArray(array) {
-        this.encoded = Uint8Array.from([...array]);
-        return this.decode();
+        return this.decode(Uint8Array.from([...array]));
     }
     fromEncoded(encoded) {
-        this.encoded = encoded;
-        return this.decode();
+        return this.decode(encoded);
     }
     toString() {
         if (!this.encoded)
@@ -1327,7 +1518,7 @@ let BasicInterface$1 = class BasicInterface {
     toHex() {
         if (!this.encoded)
             this.encode();
-        return toHex(this.encoded);
+        return toHex(this.encoded.toString().split(',').map(number => Number(number)));
     }
     /**
      * @return {String} encoded
@@ -1362,108 +1553,15 @@ let BasicInterface$1 = class BasicInterface {
                 });
             }
             this.decoded = decoded;
-            return this.encode();
+            return this.encode(decoded);
         }
     }
 };
 
-var codecs = {
-    // just a hash
-    'disco-hash': {
-        codec: parseInt('30', 16),
-        hashAlg: 'dbl-keccak-256', // ,
-        // testnet: 'olivia'
-    },
-    'peernet-peer-response': {
-        codec: parseInt('707072', 16),
-        hashAlg: 'keccak-256',
-    },
-    'peernet-peer': {
-        codec: parseInt('7070', 16),
-        hashAlg: 'keccak-256',
-    },
-    'peernet-dht': {
-        codec: parseInt('706468', 16),
-        hashAlg: 'keccak-256',
-    },
-    'peernet-dht-response': {
-        codec: parseInt('706472', 16),
-        hashAlg: 'keccak-256',
-    },
-    // data
-    'peernet-data': {
-        codec: parseInt('706461', 16),
-        hashAlg: 'keccak-256',
-    },
-    'peernet-data-response': {
-        codec: parseInt('70646172', 16),
-        hashAlg: 'keccak-256',
-    },
-    // message
-    'peernet-message': {
-        codec: parseInt('706d65', 16),
-        hashAlg: 'keccak-256',
-    },
-    // pubsub
-    'peernet-ps': {
-        codec: parseInt('707073', 16),
-        hashAlg: 'keccak-256',
-    },
-    'peernet-response': {
-        codec: parseInt('7072', 16),
-        hashAlg: 'keccak-256',
-    },
-    'peernet-request': {
-        codec: parseInt('707271', 16),
-        hashAlg: 'keccak-256',
-    },
-    // normal block
-    'leofcoin-block': {
-        codec: parseInt('6c62', 16),
-        hashAlg: 'dbl-keccak-512', // ,
-        // testnet: 'olivia'
-    },
-    'leofcoin-tx': {
-        codec: parseInt('6c74', 16),
-        hashAlg: 'dbl-keccak-512', // ,
-        // testnet: 'olivia'
-    },
-    // itx
-    'leofcoin-itx': {
-        codec: parseInt('6c69', 16),
-        hashAlg: 'keccak-512', // ,
-        // testnet: 'olivia'
-    },
-    // peer reputation
-    'leofcoin-pr': {
-        codec: parseInt('6c70', 16),
-        hashAlg: 'keccak-256', // ,
-        // testnet: 'olivia'
-    },
-    // chat message
-    'chat-message': {
-        codec: parseInt('70636d', 16),
-        hashAlg: 'dbl-keccak-256',
-    },
-    'peernet-file': {
-        codec: parseInt('7066', 16),
-        hashAlg: 'keccak-256',
-    },
-    'peernet-file-response': {
-        codec: parseInt('706672', 16),
-        hashAlg: 'keccak-256',
-    }
-};
-
-var codecs$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    default: codecs
-});
-
 let Codec$1 = class Codec extends BasicInterface$1 {
-    get codecs() {
-        return { ...globalThis.peernet.codecs, ...codecs };
-    }
+    codecBuffer;
+    codec;
+    hashAlg;
     constructor(buffer) {
         super();
         if (buffer) {
@@ -1480,17 +1578,18 @@ let Codec$1 = class Codec extends BasicInterface$1 {
                 }
             }
             else if (buffer instanceof ArrayBuffer) {
-                const encoded = new Uint8Array(buffer.byteLength);
-                for (let i = 0; i < buffer.byteLength; i++) {
-                    encoded[i] = buffer[i];
+                const codec = index$6.decode(buffer);
+                const name = this.getCodecName(codec);
+                if (name) {
+                    this.name = name;
+                    this.decode(buffer);
+                }
+                else {
+                    this.encode(buffer);
                 }
-                this.encoded = encoded;
-                // this.encoded = new Uint8Array(buffer, buffer.byteOffset, buffer.byteLength)
-                this.decode(buffer);
-                return;
             }
-            if (typeof buffer === 'string') {
-                if (this.codecs[buffer])
+            else if (typeof buffer === 'string') {
+                if (utils.getCodec(buffer))
                     this.fromName(buffer);
                 else if (this.isHex(buffer))
                     this.fromHex(buffer);
@@ -1502,7 +1601,7 @@ let Codec$1 = class Codec extends BasicInterface$1 {
                     throw new Error(`unsupported string ${buffer}`);
             }
             if (!isNaN(buffer))
-                if (this.codecs[this.getCodecName(buffer)])
+                if (utils.getCodec(buffer))
                     this.fromCodec(buffer);
         }
     }
@@ -1511,22 +1610,16 @@ let Codec$1 = class Codec extends BasicInterface$1 {
         const name = this.getCodecName(codec);
         this.name = name;
         this.encoded = encoded;
-        this.decode(encoded);
+        return this.decode(encoded);
     }
     getCodec(name) {
-        return this.codecs[name].codec;
+        return utils.getCodec(name);
     }
     getCodecName(codec) {
-        return Object.keys(this.codecs).reduce((p, c) => {
-            const item = this.codecs[c];
-            if (item.codec === codec)
-                return c;
-            else
-                return p;
-        }, undefined);
+        return utils.getCodecName(codec);
     }
     getHashAlg(name) {
-        return this.codecs[name].hashAlg;
+        return utils.getHashAlg(name);
     }
     fromCodec(codec) {
         this.name = this.getCodecName(codec);
@@ -1541,13 +1634,15 @@ let Codec$1 = class Codec extends BasicInterface$1 {
         this.hashAlg = this.getHashAlg(name);
         this.codecBuffer = index$6.encode(codec);
     }
-    decode() {
-        const codec = index$6.decode(this.encoded);
+    decode(encoded) {
+        encoded = encoded || this.encoded;
+        const codec = index$6.decode(encoded);
         this.fromCodec(codec);
+        return this.decoded;
     }
-    encode() {
-        const codec = index$6.encode(this.decoded);
-        this.encoded = codec;
+    encode(codec) {
+        codec = codec || this.codec;
+        this.encoded = index$6.encode(codec);
         return this.encoded;
     }
 };
@@ -1683,19 +1778,13 @@ let CodecHash$1 = class CodecHash extends BasicInterface$1 {
 };
 
 let FormatInterface$1 = class FormatInterface extends BasicInterface$1 {
-    set proto(value) {
-        this._proto = value;
-        this.keys = Object.keys(this._proto);
-    }
-    get proto() {
-        return this._proto;
-    }
+    hashFormat;
     init(buffer) {
         if (buffer instanceof Uint8Array)
             this.fromUint8Array(buffer);
         else if (buffer instanceof ArrayBuffer)
             this.fromArrayBuffer(buffer);
-        else if (buffer?.name === this.name)
+        else if (buffer instanceof FormatInterface$1 && buffer?.name === this.name)
             return buffer;
         else if (buffer instanceof String) {
             if (this.isHex(buffer))
@@ -1719,18 +1808,17 @@ let FormatInterface$1 = class FormatInterface extends BasicInterface$1 {
         if (codec.name)
             return true;
     }
-    decode() {
-        let encoded = this.encoded;
+    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 {
-            }
+            // try {
+            //   this.decoded = JSON.parse(this.decoded)
+            // } catch {
+            // }
         }
         else {
             throw new Error(`no codec found`);
@@ -1762,11 +1850,11 @@ let FormatInterface$1 = class FormatInterface extends BasicInterface$1 {
      * @param {Object} proto - {protoObject}
      * @param {Object} options - {hashFormat, name}
      */
-    constructor(buffer, proto, options = {}) {
+    constructor(buffer, proto, options) {
         super();
         this.proto = proto;
-        this.hashFormat = options.hashFormat || 'bs32';
-        if (options.name)
+        this.hashFormat = options?.hashFormat ? options.hashFormat : 'bs32';
+        if (options?.name)
             this.name = options.name;
         this.init(buffer);
     }
@@ -1797,54 +1885,55 @@ 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
@@ -1852,84 +1941,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;
     }
-  }
-
-  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);
-      }
+    _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];
+            }
+        }
     }
-    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);
+    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);
+                }
+            }
         }
-      }
     }
-  }
 }
 
 /**
@@ -1938,178 +2027,162 @@ class PeerDiscovery {
  * @property {Object} ptr
  */
 const lastFetched = {
-  address: {
-    value: undefined,
-    timestamp: 0,
-  },
-  ptr: {
-    value: undefined,
-    timestamp: 0,
-  },
+    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 { 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;
+    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;
+    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));
+    /**
+     *
+     */
+    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;
     }
-
-    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 import(/* webpackChunkName: "multi-wallet" */ './index-19803d3b.js');
-      globalThis.MultiWallet = importee.default;
-    }
-    const wallet = new MultiWallet(this.network);
-    wallet.recover(identity.mnemonic);
-    message.decoded.signature = wallet.sign(Buffer.from(await message.hash).slice(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);
+    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 import(/* webpackChunkName: "multi-wallet" */ './index-7018cab6.js');
+            globalThis.MultiWallet = importee.default;
+        }
+        const wallet = new MultiWallet(this.network);
+        wallet.recover(identity.mnemonic);
+        message.decoded.signature = wallet.sign(Buffer.from(await message.hash).slice(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;
     }
-
-    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 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 nothingFoundError = (hash) => {
-  return new Error(`nothing found for ${hash}`)
+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'
@@ -2280,698 +2353,645 @@ class LeofcoinStorage {
 }
 
 globalThis.LeofcoinStorage = LeofcoinStorage;
-  
 globalThis.leofcoin = globalThis.leofcoin || {};
 globalThis.pubsub = globalThis.pubsub || new LittlePubSub();
-globalThis.globalSub = globalThis.globalSub || new LittlePubSub({verbose: true});
-
+globalThis.globalSub = globalThis.globalSub || new LittlePubSub(true);
 /**
  * @access public
  * @example
  * const peernet = new Peernet();
  */
 class Peernet {
-  /**
-   * @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 = {}) {
-    this._discovered = [];
-    /**
-     * @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 defaultStores() {
-    return ['account', 'wallet', 'block', 'transaction', 'chain', 'data', 'message']
-  }
-
-  addProto(name, proto) {
-    if (!globalThis.peernet.protos[name]) globalThis.peernet.protos[name] = proto;
-  }
-
-  addCodec(name, codec) {
-    if (!this.codecs[name]) this.codecs[name] = 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);
-  }
-
-
-  /**
-   * @see MessageHandler
-   */
-  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) {
-    // peernetDHT aka closesPeer by coordinates
+    stores = [];
     /**
      * @type {Object}
      * @property {Object} peer Instance of Peer
      */
-    this.dht = new DhtEarth();
+    dht = new DhtEarth();
+    /** @leofcoin/peernet-swarm/client */
+    client;
+    network;
+    stars;
+    networkVersion;
+    bw;
     /**
-     * @type {Map}
-     * @property {Object} peer Instance of Peer
+     * @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'});
      */
-    this.stores = [];
-    this.codecs = {...codecs$1};
-    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-bb950ed7.js');
-
+    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 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.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);
+    }
     /**
-     * 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
+     * @see MessageHandler
      */
-
-    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);
+    prepareMessage(data) {
+        return this._messageHandler.prepareMessage(data);
     }
-
-    const accountExists = await accountStore.has('public');
-    if (accountExists) {
-      const pub = await accountStore.get('public');
-      this.id = JSON.parse(new TextDecoder().decode(pub)).walletId;
-      let accounts = await walletStore.get('accounts');
-      accounts = new TextDecoder().decode(accounts);
-      const selected = await walletStore.get('selected-account');
-      globalThis.peernet.selectedAccount = new TextDecoder().decode(selected);
-
-      // fixing account issue (string while needs to be a JSON)
-      // TODO: remove when on mainnet
-      try {
-        this.accounts = JSON.parse(accounts);
-      } catch {
-        this.accounts = [accounts.split(',')];
-      }
-    } else {
-      const importee = await import(/* webpackChunkName: "generate-account" */ './index-73b8d9b9.js');
-      const generateAccount = importee.default;
-      const {identity, accounts, config} = await generateAccount(this.network);
-      // await accountStore.put('config', JSON.stringify(config));
-      await accountStore.put('public', JSON.stringify({walletId: identity.walletId}));
-      
-      await walletStore.put('version', String(1));
-      await walletStore.put('accounts', JSON.stringify(accounts));
-      await walletStore.put('selected-account', accounts[0][1]);
-      await walletStore.put('identity', JSON.stringify(identity));
-
-      globalThis.peernet.selectedAccount = accounts[0][1];
-      this.id = identity.walletId;
+    /**
+     * @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);
     }
-    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
+     * @return {String} id - peerId
      */
-    pubsub.subscribe('peer:data', dataHandler);
-
-
-    const importee = await import(/* webpackChunkName: "peernet-swarm" */ './client-13d9b3de.js');
+    getConnection(id) {
+        return this.client.connections[id];
+    }
     /**
-     * @access public
-     * @type {PeernetClient}
+     * @private
+     *
+     * @param {Object} options
+     * @param {String} options.root - path to root directory
+     *
+     * @return {Promise} instance of Peernet
      */
-    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();
-      });
+    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-452642e3.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);
+        }
+        const accountExists = await accountStore.has('public');
+        if (accountExists) {
+            const pub = await accountStore.get('public');
+            this.id = JSON.parse(new TextDecoder().decode(pub)).walletId;
+            let accounts = await walletStore.get('accounts');
+            accounts = new TextDecoder().decode(accounts);
+            const selected = await walletStore.get('selected-account');
+            globalThis.peernet.selectedAccount = new TextDecoder().decode(selected);
+            // fixing account issue (string while needs to be a JSON)
+            // TODO: remove when on mainnet
+            try {
+                this.accounts = JSON.parse(accounts);
+            }
+            catch {
+                this.accounts = [accounts.split(',')];
+            }
+        }
+        else {
+            const importee = await import(/* webpackChunkName: "generate-account" */ './index-ddd5774f.js');
+            const generateAccount = importee.default;
+            const { identity, accounts, config } = await generateAccount(this.network);
+            // await accountStore.put('config', JSON.stringify(config));
+            await accountStore.put('public', JSON.stringify({ walletId: identity.walletId }));
+            await walletStore.put('version', String(1));
+            await walletStore.put('accounts', JSON.stringify(accounts));
+            await walletStore.put('selected-account', accounts[0][1]);
+            await walletStore.put('identity', JSON.stringify(identity));
+            globalThis.peernet.selectedAccount = accounts[0][1];
+            this.id = identity.walletId;
+        }
+        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-ed00c639.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;
     }
-    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);
+    addRequestHandler(name, method) {
+        this.requestProtos[name] = method;
     }
-
-    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});
-
+    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 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);
+    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);
+            }
+        }
     }
-  }
-
-  /**
-   * @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 'peenet-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);
-      }
+    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);
+        }
     }
-  }
-
-  /**
-   * 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));
-      }
+    /**
+     * @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 'peenet-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);
+            }
+        }
     }
-    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'),
+    /**
+     * 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);
     }
-  }
-
-  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),
+    /**
+     * 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;
     }
-  }
-
-  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);
-      }
-      data = new Uint8Array(Object.values(data));
-      const proto = await protoFor(data);
-      // TODO: store data automaticly or not
-      return BufferToUint8Array(proto.decoded.data)
-
-      // this.put(hash, proto.decoded.data)
+    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'),
+        };
     }
-    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 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),
+        };
     }
-  }
-
-  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),
+    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);
+            }
+            data = new Uint8Array(Object.values(data));
+            const proto = await protoFor(data);
+            // TODO: store data automaticly or not
+            return BufferToUint8Array(proto.decoded.data);
+            // this.put(hash, proto.decoded.data)
+        }
+        return;
     }
-  }
-
-  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),
+    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),
+        };
     }
-  }
-
-  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
+    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),
+        };
     }
-    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
+    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;
     }
-  }
-
-  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;