@leofcoin/peernet 0.18.0 → 0.18.2

package/exports/peernet.js

@@ -1,57 +1,59 @@
 import '@vandeurenglenn/debug';
 import PubSub from '@vandeurenglenn/little-pubsub';
-import { Codec, codecs } from '@leofcoin/codec-format-interface';
+import { Codec } from '@leofcoin/codec-format-interface';
 import LeofcoinStorage from '@leofcoin/storage';
+import { utils } from '@leofcoin/codecs';
 
 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
@@ -59,84 +61,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]
-      }
-    }
-  }
-
-  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);
+    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];
+            }
         }
-      }
-      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);
+                }
+            }
         }
-      }
     }
-  }
 }
 
 /**
@@ -145,873 +147,804 @@ 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));
-    }
-
-    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;
-  }
+    /**
+     *
+     */
+    constructor() {
+        this.providerMap = new Map();
+    }
+    /**
+     * @param {Object} address
+     * @return {Object} {latitude: lat, longitude: lon}
+     */
+    async getCoordinates(address) {
+        // const {address} = parseAddress(provider)
+        const request = `https://whereis.leofcoin.org/?ip=${address}`;
+        let response = await fetch(request);
+        response = await response.json();
+        const { lat, lon } = response;
+        return { latitude: lat, longitude: lon };
+    }
+    /**
+     * @param {Object} peer
+     * @param {Object} provider
+     * @return {Object} {provider, distance}
+     */
+    async getDistance(peer, provider) {
+        const { latitude, longitude } = await this.getCoordinates(provider.address);
+        return { provider, distance: distanceInKmBetweenEarthCoordinates(peer.latitude, peer.longitude, latitude, longitude) };
+    }
+    /**
+     * @param {Array} providers
+     * @return {Object} closestPeer
+     */
+    async closestPeer(providers) {
+        let all = [];
+        const address = await getAddress();
+        const peerLoc = await this.getCoordinates(address);
+        for (const provider of providers) {
+            if (provider.address === '127.0.0.1')
+                all.push({ provider, distance: 0 });
+            else
+                all.push(this.getDistance(peerLoc, provider));
+        }
+        all = await Promise.all(all);
+        all = all.sort((previous, current) => previous.distance - current.distance);
+        return all[0].provider;
+    }
+    /**
+     * @param {String} hash
+     * @return {Array} providers
+     */
+    providersFor(hash) {
+        return this.providerMap.get(hash);
+    }
+    /**
+     * @param {String} address
+     * @param {String} hash
+     * @return {Array} providers
+     */
+    async addProvider(address, hash) {
+        let providers = [];
+        if (this.providerMap.has(hash))
+            providers = this.providerMap.get(hash);
+        providers = new Set([...providers, address]);
+        this.providerMap.set(hash, providers);
+        return providers;
+    }
 }
 
 class MessageHandler {
-  constructor(network) {
-    this.network = network;
-  }
-  /**
-   * hash and sign message
-   *
-   * @param {object} message
-   * @param {Buffer} message.from peer id
-   * @param {Buffer} message.to peer id
-   * @param {string} message.data Peernet message
-   * (PeernetMessage excluded) encoded as a string
-   * @return message
-   */
-  async hashAndSignMessage(message) {
-    let identity = await walletStore.get('identity');
-    identity = JSON.parse(identity);
-    if (!globalThis.MultiWallet) {
-      const importee = await import(/* webpackChunkName: "multi-wallet" */ '@leofcoin/multi-wallet');
-      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
-  }
+    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" */ '@leofcoin/multi-wallet');
+            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;
+    }
 }
 
-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 dataHandler = async (message) => {
+    if (!message)
+        return;
+    const { data, id, from } = message;
+    const proto = await protoFor(data);
+    peernet._protoHandler({ id, proto }, peernet.client.connections[from], from);
 };
 
-const dhtError = (proto) => {
-  const text = `Received proto ${proto.name} expected peernet-dht-response`;
-  return new Error(`Routing error: ${text}`)
-};
-
-const nothingFoundError = (hash) => {
-  return new Error(`nothing found for ${hash}`)
+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}`);
 };
 
 globalThis.LeofcoinStorage = LeofcoinStorage;
-  
 globalThis.leofcoin = globalThis.leofcoin || {};
 globalThis.pubsub = globalThis.pubsub || new PubSub();
-globalThis.globalSub = globalThis.globalSub || new PubSub({verbose: true});
-
+globalThis.globalSub = globalThis.globalSub || new PubSub(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};
-    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-d8852e16.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);
-    }
-
-    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" */ '@leofcoin/generate-account');
-      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)
-      // })
-    });
-
+    prepareMessage(data) {
+        return this._messageHandler.prepareMessage(data);
+    }
     /**
-     * converts data -> message -> proto
-     * @see DataHandler
+     * @access public
+     *
+     * @return {Array} peerId
      */
-    pubsub.subscribe('peer:data', dataHandler);
-
-
-    const importee = await import(/* webpackChunkName: "peernet-swarm" */ '@leofcoin/peernet-swarm/client');
+    get peers() {
+        return Object.keys(this.client.connections);
+    }
+    get connections() {
+        return Object.values(this.client.connections);
+    }
+    get peerEntries() {
+        return Object.entries(this.client.connections);
+    }
     /**
-     * @access public
-     * @type {PeernetClient}
+     * @return {String} id - peerId
      */
-    this.client = new importee.default(this.id, this.networkVersion, this.stars);
-    if (globalThis.navigator) {
-      globalThis.addEventListener('beforeunload', async () => this.client.close());
-    } else {
-      process.on('SIGTERM', async () => {
-        process.stdin.resume();
-        await this.client.close();
-        process.exit();
-      });
-    }
-    return this
-  }
-
-  addRequestHandler(name, method) {
-    this.requestProtos[name] = method;
-  }
-
-  sendMessage(peer, id, data) {
-    if (peer.readyState === 'open') {
-      peer.send(data, id);
-      this.bw.up += data.length;
-    } else if (peer.readyState === 'closed') ;
-
-  }
-
-  async handleDHT(peer, id, proto) {
-    let { hash, store } = proto.decoded;
-    let has;
-
-    if (store) {
-      store = globalThis[`${store}Store`];
-      has = store.private ? false : await store.has(hash);
-    } else {
-      has = await this.has(hash);
-    }
-
-    const data = await new globalThis.peernet.protos['peernet-dht-response']({hash, has});
-    const node = await this.prepareMessage(data);
-
-    this.sendMessage(peer, id, node.encoded);
-  }
-
-  async handleData(peer, id, proto) {
-    let { hash, store } = proto.decoded;
-    let data;
-    store = globalThis[`${store}Store`] || await this.whichStore([...this.stores], hash);
-    
-    if (store && !store.private) {
-      data = await store.get(hash);
-
-      if (data) {
-        data = await new globalThis.peernet.protos['peernet-data-response']({hash, data});
-
-        const node = await this.prepareMessage(data);
-        this.sendMessage(peer, id, node.encoded);
-      }
-    }
-  }
-
-  async handleRequest(peer, id, proto) {
-    const method = this.requestProtos[proto.decoded.request];
-    if (method) {
-      const data = await method();
-      const node = await this.prepareMessage(data);
-      this.sendMessage(peer, id, node.encoded);
-    }
-  }
-
-  /**
-   * @private
-   *
-   * @param {Buffer} message - peernet message
-   * @param {PeernetPeer} peer - peernet peer
-   */
-  async _protoHandler(message, peer, from) {
-    const {id, proto} = message;
-    this.bw.down += proto.encoded.length;
-    switch(proto.name) {
-      case 'peernet-dht': {
-        this.handleDHT(peer, id, proto);
-        break
-      }
-      case '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);
-      }
-    }
-  }
-
-  /**
-   * performs a walk and resolves first encounter
-   *
-   * @param {String} hash
-   */
-  async walk(hash) {
-    if (!hash) throw new Error('hash expected, received undefined')
-    const data = await new globalThis.peernet.protos['peernet-dht']({hash});
-    this.client.id;
-    const walk = async peer => {
-      const node = await this.prepareMessage(data);
-      let result = await peer.request(node.encoded);
-      result = new Uint8Array(Object.values(result));
-      const proto = await protoFor(result);
-      if (proto.name !== 'peernet-dht-response') throw dhtError(proto.name)
-
-      // TODO: give ip and port (just used for location)
-      if (!peer.connection.remoteAddress || !peer.connection.localAddress) {
-        peer.connection.remoteFamily = 'ipv4';
-        peer.connection.remoteAddress = '127.0.0.1';
-        peer.connection.remotePort = '0000';
-      }
-
-      const peerInfo = {
-        family: peer.connection.remoteFamily || peer.connection.localFamily,
-        address: peer.connection.remoteAddress || peer.connection.localAddress,
-        port: peer.connection.remotePort || peer.connection.localPort,
-        id: peer.peerId,
-      };
-
-      if (proto.decoded.has) this.dht.addProvider(peerInfo, proto.decoded.hash);
-    };
-    let walks = [];
-    for (const peer of this.connections) {
-      if (peer.peerId !== this.id) {
-        walks.push(walk(peer));
-      }
-    }
-    return Promise.all(walks)
-  }
-
-  /**
-   * Override DHT behavior, try's finding the content three times
-   *
-   * @param {String} hash
-   */
-  async providersFor(hash) {
-    let providers = await this.dht.providersFor(hash);
-    // walk the network to find a provider
-    if (!providers || providers.length === 0) {
-      await this.walk(hash);
-      providers = await this.dht.providersFor(hash);
-      // second walk the network to find a provider
-      if (!providers || providers.length === 0) {
-        await this.walk(hash);
-        providers = await this.dht.providersFor(hash);
-      }
-      // last walk
-      if (!providers || providers.length === 0) {
-        await this.walk(hash);
-        providers = await this.dht.providersFor(hash);
-      }
-    }
-    // undefined if no providers given
-    return providers
-  }
-
-  get block() {
-    return {
-      get: async (hash) => {
-        const data = await blockStore.has(hash);
-        if (data) return blockStore.get(hash)
-        return this.requestData(hash, 'block')
-      },
-      put: async (hash, data) => {
-        if (await blockStore.has(hash)) return
-        return await blockStore.put(hash, data)
-      },
-      has: async (hash) => await blockStore.has(hash, 'block'),
-    }
-  }
-
-  get transaction() {
-    return {
-      get: async (hash) => {
-        const data = await transactionStore.has(hash);
-        if (data) return await transactionStore.get(hash)
-        return this.requestData(hash, 'transaction')
-      },
-      put: async (hash, data) => {
-        if (await transactionStore.has(hash)) return
-        return await transactionStore.put(hash, data)
-      },
-      has: async (hash) => await transactionStore.has(hash),
-    }
-  }
-
-  async requestData(hash, store) {
-    const providers = await this.providersFor(hash);
-    if (!providers || providers.size === 0) throw nothingFoundError(hash)
-    debug(`found ${providers.size} provider(s) for ${hash}`);
-    // get closest peer on earth
-    const closestPeer = await this.dht.closestPeer(providers);
-    // get peer instance by id
-    if (!closestPeer || !closestPeer.id) return this.requestData(hash, store?.name || store)
-
-    const id = closestPeer.id;
-    if (this.connections) {
-      let closest = this.connections.filter((peer) => {
-        if (peer.peerId === id) return peer
-      });
-
-      let data = await new globalThis.peernet.protos['peernet-data']({hash, store: store?.name || store});
-
-      const node = await this.prepareMessage(data);
-      if (closest[0]) data = await closest[0].request(node.encoded);
-      else {
-        closest = this.connections.filter((peer) => {
-          if (peer.peerId === id) return peer
+    getConnection(id) {
+        return this.client.connections[id];
+    }
+    /**
+     * @private
+     *
+     * @param {Object} options
+     * @param {String} options.root - path to root directory
+     *
+     * @return {Promise} instance of Peernet
+     */
+    async _init(options) {
+        this.requestProtos = {};
+        this.storePrefix = options.storePrefix;
+        this.root = options.root;
+        const { RequestMessage, ResponseMessage, PeerMessage, PeerMessageResponse, PeernetMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PsMessage, ChatMessage, PeernetFile
+        // FolderMessageResponse
+         } = await import(/* webpackChunkName: "messages" */ './messages-ebdc8c69.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" */ '@leofcoin/generate-account');
+            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)
+            // })
         });
-        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 message() {
-    return {
-      /**
-       * Get content for given message hash
-       *
-       * @param {String} hash
-       */
-      get: async (hash) => {
-        debug(`get message ${hash}`);
-        const message = await messageStore.has(hash);
-        if (message) return await messageStore.get(hash)
-        return this.requestData(hash, 'message')
-      },
-      /**
-       * put message content
-       *
-       * @param {String} hash
-       * @param {Buffer} message
-       */
-      put: async (hash, message) => await messageStore.put(hash, message),
-      /**
-       * @param {String} hash
-       * @return {Boolean}
-       */
-      has: async (hash) => await messageStore.has(hash),
-    }
-  }
-
-  get data() {
-    return {
-      /**
-       * Get content for given data hash
-       *
-       * @param {String} hash
-       */
-      get: async (hash) => {
-        debug(`get data ${hash}`);
-        const data = await dataStore.has(hash);
-        if (data) return await dataStore.get(hash)
-        return this.requestData(hash, 'data')
-      },
-      /**
-       * put data content
-       *
-       * @param {String} hash
-       * @param {Buffer} data
-       */
-      put: async (hash, data) => await dataStore.put(hash, data),
-      /**
-       * @param {String} hash
-       * @return {Boolean}
-       */
-      has: async (hash) => await dataStore.has(hash),
-    }
-  }
-
-  get folder() {
-    return {
-      /**
-       * Get content for given data hash
-       *
-       * @param {String} hash
-       */
-      get: async (hash) => {
-        debug(`get data ${hash}`);
-        const data = await dataStore.has(hash);
-        if (data) return await dataStore.get(hash)
-        return this.requestData(hash, 'data')
-      },
-      /**
-       * put data content
-       *
-       * @param {String} hash
-       * @param {Buffer} data
-       */
-      put: async (hash, data) => await dataStore.put(hash, data),
-      /**
-       * @param {String} hash
-       * @return {Boolean}
-       */
-      has: async (hash) => await dataStore.has(hash),
-    }
-  }
-
-  async addFolder(files) {
-    const links = [];
-    for (const file of files) {
-      const fileNode = await new globalThis.peernet.protos['peernet-file'](file);
-      const hash = await fileNode.hash;
-      await dataStore.put(hash, fileNode.encoded);
-      links.push({hash, path: file.path});
-    }
-    const node = await new globalThis.peernet.protos['peernet-file']({path: '/', links});
-    const hash = await node.hash;
-    await dataStore.put(hash, node.encoded);
-
-    return hash
-  }
-
-  async ls(hash, options) {
-    let data;
-    const has = await dataStore.has(hash);
-    data = has ? await dataStore.get(hash) : await this.requestData(hash, 'data');
-
-    const node = await new peernet.protos['peernet-file'](data);
-    await node.decode();
-    console.log(data);
-    const paths = [];
-    if (node.decoded?.links.length === 0) throw new Error(`${hash} is a file`)
-    for (const {path, hash} of node.decoded.links) {
-      paths.push({path, hash});
-    }
-    if (options?.pin) await dataStore.put(hash, node.encoded);
-    return paths
-  }
-
-  async cat(hash, options) {
-    let data;
-    const has = await dataStore.has(hash);
-    data = has ? await dataStore.get(hash) : await this.requestData(hash, 'data');
-    const node = await new peernet.protos['peernet-file'](data);
-
-    if (node.decoded?.links.length > 0) throw new Error(`${hash} is a directory`)
-    if (options?.pin) await dataStore.put(hash, node.encoded);
-    return node.decoded.content
-  }
-
-  /**
-   * goes trough given stores and tries to find data for given hash
-   * @param {Array} stores
-   * @param {string} hash
-   */
-  async whichStore(stores, hash) {
-    let store = stores.pop();
-    store = globalThis[`${store}Store`];
-    if (store) {
-      const has = await store.has(hash);
-      if (has) return store
-      if (stores.length > 0) return this.whichStore(stores, hash)
-    } else return
-  }
-
-  /**
-   * Get content for given hash
-   *
-   * @param {String} hash - the hash of the wanted data
-   * @param {String} store - storeName to access
-   */
-  async get(hash, store) {
-    debug(`get ${hash}`);
-    let data;
-    if (store) store = globalThis[`${store}Store`];
-    if (!store) store = await this.whichStore([...this.stores], hash);
-    if (store && await store.has(hash)) data = await store.get(hash);
-    if (data) return data
-
-    return this.requestData(hash, store?.name || store)
-  }
-
-  /**
-   * put content
-   *
-   * @param {String} hash
-   * @param {Buffer} data
-   * @param {String} store - storeName to access
-   */
-  async put(hash, data, store = 'data') {
-    store = globalThis[`${store}Store`];
-    return store.put(hash, data)
-  }
-
-  /**
-   * @param {String} hash
-   * @return {Boolean}
-   */
-  async has(hash) {
-    const store = await this.whichStore([...this.stores], hash);
-    if (store) {
-      return store.private ? false : true
-    }
-    return false
-  }
-
-  /**
-   *
-   * @param {String} topic
-   * @param {String|Object|Array|Boolean|Buffer} data
-   */
-  async publish(topic, data) {
-    // globalSub.publish(topic, data)
-    const id = Math.random().toString(36).slice(-12);
-    data = await new globalThis.peernet.protos['peernet-ps']({data, topic});
-    for (const peer of this.connections) {
-      if (peer.peerId !== this.peerId) {
+        /**
+         * converts data -> message -> proto
+         * @see DataHandler
+         */
+        pubsub.subscribe('peer:data', dataHandler);
+        const importee = await import('@leofcoin/peernet-swarm/client');
+        /**
+         * @access public
+         * @type {PeernetClient}
+         */
+        this.client = new importee.default(this.id, this.networkVersion, this.stars);
+        if (globalThis.navigator) {
+            globalThis.addEventListener('beforeunload', async () => this.client.close());
+        }
+        else {
+            process.on('SIGTERM', async () => {
+                process.stdin.resume();
+                await this.client.close();
+                process.exit();
+            });
+        }
+        return this;
+    }
+    addRequestHandler(name, method) {
+        this.requestProtos[name] = method;
+    }
+    sendMessage(peer, id, data) {
+        if (peer.readyState === 'open') {
+            peer.send(data, id);
+            this.bw.up += data.length;
+        }
+        else if (peer.readyState === 'closed') ;
+    }
+    async handleDHT(peer, id, proto) {
+        let { hash, store } = proto.decoded;
+        let has;
+        if (store) {
+            store = globalThis[`${store}Store`];
+            has = store.private ? false : await store.has(hash);
+        }
+        else {
+            has = await this.has(hash);
+        }
+        const data = await new globalThis.peernet.protos['peernet-dht-response']({ hash, has });
         const node = await this.prepareMessage(data);
         this.sendMessage(peer, id, node.encoded);
-      }
-      // 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
-  }
+    }
+    async handleData(peer, id, proto) {
+        let { hash, store } = proto.decoded;
+        let data;
+        store = globalThis[`${store}Store`] || await this.whichStore([...this.stores], hash);
+        if (store && !store.private) {
+            data = await store.get(hash);
+            if (data) {
+                data = await new globalThis.peernet.protos['peernet-data-response']({ hash, data });
+                const node = await this.prepareMessage(data);
+                this.sendMessage(peer, id, node.encoded);
+            }
+        }
+    }
+    async handleRequest(peer, id, proto) {
+        const method = this.requestProtos[proto.decoded.request];
+        if (method) {
+            const data = await method();
+            const node = await this.prepareMessage(data);
+            this.sendMessage(peer, id, node.encoded);
+        }
+    }
+    /**
+     * @private
+     *
+     * @param {Buffer} message - peernet message
+     * @param {PeernetPeer} peer - peernet peer
+     */
+    async _protoHandler(message, peer, from) {
+        const { id, proto } = message;
+        this.bw.down += proto.encoded.length;
+        switch (proto.name) {
+            case 'peernet-dht': {
+                this.handleDHT(peer, id, proto);
+                break;
+            }
+            case '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);
+            }
+        }
+    }
+    /**
+     * performs a walk and resolves first encounter
+     *
+     * @param {String} hash
+     */
+    async walk(hash) {
+        if (!hash)
+            throw new Error('hash expected, received undefined');
+        const data = await new globalThis.peernet.protos['peernet-dht']({ hash });
+        this.client.id;
+        const walk = async (peer) => {
+            const node = await this.prepareMessage(data);
+            let result = await peer.request(node.encoded);
+            result = new Uint8Array(Object.values(result));
+            const proto = await protoFor(result);
+            if (proto.name !== 'peernet-dht-response')
+                throw dhtError(proto.name);
+            // TODO: give ip and port (just used for location)
+            if (!peer.connection.remoteAddress || !peer.connection.localAddress) {
+                peer.connection.remoteFamily = 'ipv4';
+                peer.connection.remoteAddress = '127.0.0.1';
+                peer.connection.remotePort = '0000';
+            }
+            const peerInfo = {
+                family: peer.connection.remoteFamily || peer.connection.localFamily,
+                address: peer.connection.remoteAddress || peer.connection.localAddress,
+                port: peer.connection.remotePort || peer.connection.localPort,
+                id: peer.peerId,
+            };
+            if (proto.decoded.has)
+                this.dht.addProvider(peerInfo, proto.decoded.hash);
+        };
+        let walks = [];
+        for (const peer of this.connections) {
+            if (peer.peerId !== this.id) {
+                walks.push(walk(peer));
+            }
+        }
+        return Promise.all(walks);
+    }
+    /**
+     * Override DHT behavior, try's finding the content three times
+     *
+     * @param {String} hash
+     */
+    async providersFor(hash) {
+        let providers = await this.dht.providersFor(hash);
+        // walk the network to find a provider
+        if (!providers || providers.length === 0) {
+            await this.walk(hash);
+            providers = await this.dht.providersFor(hash);
+            // second walk the network to find a provider
+            if (!providers || providers.length === 0) {
+                await this.walk(hash);
+                providers = await this.dht.providersFor(hash);
+            }
+            // last walk
+            if (!providers || providers.length === 0) {
+                await this.walk(hash);
+                providers = await this.dht.providersFor(hash);
+            }
+        }
+        // undefined if no providers given
+        return providers;
+    }
+    get block() {
+        return {
+            get: async (hash) => {
+                const data = await blockStore.has(hash);
+                if (data)
+                    return blockStore.get(hash);
+                return this.requestData(hash, 'block');
+            },
+            put: async (hash, data) => {
+                if (await blockStore.has(hash))
+                    return;
+                return await blockStore.put(hash, data);
+            },
+            has: async (hash) => await blockStore.has(hash, 'block'),
+        };
+    }
+    get transaction() {
+        return {
+            get: async (hash) => {
+                const data = await transactionStore.has(hash);
+                if (data)
+                    return await transactionStore.get(hash);
+                return this.requestData(hash, 'transaction');
+            },
+            put: async (hash, data) => {
+                if (await transactionStore.has(hash))
+                    return;
+                return await transactionStore.put(hash, data);
+            },
+            has: async (hash) => await transactionStore.has(hash),
+        };
+    }
+    async requestData(hash, store) {
+        const providers = await this.providersFor(hash);
+        if (!providers || providers.size === 0)
+            throw nothingFoundError(hash);
+        debug(`found ${providers.size} provider(s) for ${hash}`);
+        // get closest peer on earth
+        const closestPeer = await this.dht.closestPeer(providers);
+        // get peer instance by id
+        if (!closestPeer || !closestPeer.id)
+            return this.requestData(hash, store?.name || store);
+        const id = closestPeer.id;
+        if (this.connections) {
+            let closest = this.connections.filter((peer) => {
+                if (peer.peerId === id)
+                    return peer;
+            });
+            let data = await new globalThis.peernet.protos['peernet-data']({ hash, store: store?.name || store });
+            const node = await this.prepareMessage(data);
+            if (closest[0])
+                data = await closest[0].request(node.encoded);
+            else {
+                closest = this.connections.filter((peer) => {
+                    if (peer.peerId === id)
+                        return peer;
+                });
+                if (closest[0])
+                    data = await closest[0].request(node.encoded);
+            }
+            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 message() {
+        return {
+            /**
+             * Get content for given message hash
+             *
+             * @param {String} hash
+             */
+            get: async (hash) => {
+                debug(`get message ${hash}`);
+                const message = await messageStore.has(hash);
+                if (message)
+                    return await messageStore.get(hash);
+                return this.requestData(hash, 'message');
+            },
+            /**
+             * put message content
+             *
+             * @param {String} hash
+             * @param {Buffer} message
+             */
+            put: async (hash, message) => await messageStore.put(hash, message),
+            /**
+             * @param {String} hash
+             * @return {Boolean}
+             */
+            has: async (hash) => await messageStore.has(hash),
+        };
+    }
+    get data() {
+        return {
+            /**
+             * Get content for given data hash
+             *
+             * @param {String} hash
+             */
+            get: async (hash) => {
+                debug(`get data ${hash}`);
+                const data = await dataStore.has(hash);
+                if (data)
+                    return await dataStore.get(hash);
+                return this.requestData(hash, 'data');
+            },
+            /**
+             * put data content
+             *
+             * @param {String} hash
+             * @param {Buffer} data
+             */
+            put: async (hash, data) => await dataStore.put(hash, data),
+            /**
+             * @param {String} hash
+             * @return {Boolean}
+             */
+            has: async (hash) => await dataStore.has(hash),
+        };
+    }
+    get folder() {
+        return {
+            /**
+             * Get content for given data hash
+             *
+             * @param {String} hash
+             */
+            get: async (hash) => {
+                debug(`get data ${hash}`);
+                const data = await dataStore.has(hash);
+                if (data)
+                    return await dataStore.get(hash);
+                return this.requestData(hash, 'data');
+            },
+            /**
+             * put data content
+             *
+             * @param {String} hash
+             * @param {Buffer} data
+             */
+            put: async (hash, data) => await dataStore.put(hash, data),
+            /**
+             * @param {String} hash
+             * @return {Boolean}
+             */
+            has: async (hash) => await dataStore.has(hash),
+        };
+    }
+    async addFolder(files) {
+        const links = [];
+        for (const file of files) {
+            const fileNode = await new globalThis.peernet.protos['peernet-file'](file);
+            const hash = await fileNode.hash;
+            await dataStore.put(hash, fileNode.encoded);
+            links.push({ hash, path: file.path });
+        }
+        const node = await new globalThis.peernet.protos['peernet-file']({ path: '/', links });
+        const hash = await node.hash;
+        await dataStore.put(hash, node.encoded);
+        return hash;
+    }
+    async ls(hash, options) {
+        let data;
+        const has = await dataStore.has(hash);
+        data = has ? await dataStore.get(hash) : await this.requestData(hash, 'data');
+        const node = await new peernet.protos['peernet-file'](data);
+        await node.decode();
+        console.log(data);
+        const paths = [];
+        if (node.decoded?.links.length === 0)
+            throw new Error(`${hash} is a file`);
+        for (const { path, hash } of node.decoded.links) {
+            paths.push({ path, hash });
+        }
+        if (options?.pin)
+            await dataStore.put(hash, node.encoded);
+        return paths;
+    }
+    async cat(hash, options) {
+        let data;
+        const has = await dataStore.has(hash);
+        data = has ? await dataStore.get(hash) : await this.requestData(hash, 'data');
+        const node = await new peernet.protos['peernet-file'](data);
+        if (node.decoded?.links.length > 0)
+            throw new Error(`${hash} is a directory`);
+        if (options?.pin)
+            await dataStore.put(hash, node.encoded);
+        return node.decoded.content;
+    }
+    /**
+     * goes trough given stores and tries to find data for given hash
+     * @param {Array} stores
+     * @param {string} hash
+     */
+    async whichStore(stores, hash) {
+        let store = stores.pop();
+        store = globalThis[`${store}Store`];
+        if (store) {
+            const has = await store.has(hash);
+            if (has)
+                return store;
+            if (stores.length > 0)
+                return this.whichStore(stores, hash);
+        }
+        else
+            return;
+    }
+    /**
+     * Get content for given hash
+     *
+     * @param {String} hash - the hash of the wanted data
+     * @param {String} store - storeName to access
+     */
+    async get(hash, store) {
+        debug(`get ${hash}`);
+        let data;
+        if (store)
+            store = globalThis[`${store}Store`];
+        if (!store)
+            store = await this.whichStore([...this.stores], hash);
+        if (store && await store.has(hash))
+            data = await store.get(hash);
+        if (data)
+            return data;
+        return this.requestData(hash, store?.name || store);
+    }
+    /**
+     * put content
+     *
+     * @param {String} hash
+     * @param {Buffer} data
+     * @param {String} store - storeName to access
+     */
+    async put(hash, data, store = 'data') {
+        store = globalThis[`${store}Store`];
+        return store.put(hash, data);
+    }
+    /**
+     * @param {String} hash
+     * @return {Boolean}
+     */
+    async has(hash) {
+        const store = await this.whichStore([...this.stores], hash);
+        if (store) {
+            return store.private ? false : true;
+        }
+        return false;
+    }
+    /**
+     *
+     * @param {String} topic
+     * @param {String|Object|Array|Boolean|Buffer} data
+     */
+    async publish(topic, data) {
+        // globalSub.publish(topic, data)
+        const id = Math.random().toString(36).slice(-12);
+        data = await new globalThis.peernet.protos['peernet-ps']({ data, topic });
+        for (const peer of this.connections) {
+            if (peer.peerId !== this.peerId) {
+                const node = await this.prepareMessage(data);
+                this.sendMessage(peer, id, node.encoded);
+            }
+            // TODO: if peer subscribed
+        }
+    }
+    createHash(data, name) {
+        return new CodeHash(data, { name });
+    }
+    /**
+     *
+     * @param {String} topic
+     * @param {Method} cb
+     */
+    async subscribe(topic, callback) {
+        // TODO: if peer subscribed
+        globalSub.subscribe(topic, callback);
+    }
+    async removePeer(peer) {
+        return this.client.removePeer(peer);
+    }
+    get Buffer() {
+        return Buffer;
+    }
 }
 globalThis.Peernet = Peernet;