@leofcoin/peernet 1.1.58 → 1.1.59

package/src/peernet.ts

@@ -1,34 +1,34 @@
-import "@vandeurenglenn/debug";
-import PubSub from "@vandeurenglenn/little-pubsub";
-import PeerDiscovery from "./discovery/peer-discovery.js";
-import DHT, { DHTProvider, DHTProviderDistanceResult } from "./dht/dht.js";
-import { BufferToUint8Array, protoFor, target } from "./utils/utils.js";
-import MessageHandler from "./handlers/message.js";
-import dataHandler from "./handlers/data.js";
-import { dhtError, nothingFoundError } from "./errors/errors.js";
-import LeofcoinStorageClass from "@leofcoin/storage";
-import { utils as codecUtils } from "@leofcoin/codecs";
-import Identity from "./identity.js";
-import swarm, { PeerId } from "@netpeer/p2pt-swarm";
-import P2PTPeer from "@netpeer/p2pt-swarm/peer";
-
-globalThis.LeofcoinStorage = LeofcoinStorageClass;
-
-globalThis.leofcoin = globalThis.leofcoin || {};
-globalThis.pubsub = globalThis.pubsub || new PubSub();
-globalThis.globalSub = globalThis.globalSub || new PubSub();
+import '@vandeurenglenn/debug'
+import PubSub from '@vandeurenglenn/little-pubsub'
+import PeerDiscovery from './discovery/peer-discovery.js'
+import DHT, { DHTProvider, DHTProviderDistanceResult } from './dht/dht.js'
+import { BufferToUint8Array, protoFor, target } from './utils/utils.js'
+import MessageHandler from './handlers/message.js'
+import dataHandler from './handlers/data.js'
+import { dhtError, nothingFoundError } from './errors/errors.js'
+import { Storage as LeofcoinStorageClass } from '@leofcoin/storage'
+import { utils as codecUtils } from '@leofcoin/codecs'
+import Identity from './identity.js'
+import swarm, { PeerId } from '@netpeer/p2pt-swarm'
+import P2PTPeer from '@netpeer/p2pt-swarm/peer'
+
+globalThis.LeofcoinStorage = LeofcoinStorageClass
+
+globalThis.leofcoin = globalThis.leofcoin || {}
+globalThis.pubsub = globalThis.pubsub || new PubSub()
+globalThis.globalSub = globalThis.globalSub || new PubSub()
 
 declare global {
-  var LeofcoinStorage: typeof LeofcoinStorageClass;
-  var peernet: Peernet;
-  var pubsub: PubSub;
-  var globalSub: PubSub;
-  var blockStore: LeofcoinStorageClass;
-  var transactionStore: LeofcoinStorageClass;
-  var messageStore: LeofcoinStorageClass;
-  var dataStore: LeofcoinStorageClass;
-  var walletStore: LeofcoinStorageClass;
-  var chainStore: LeofcoinStorageClass;
+  var LeofcoinStorage: typeof LeofcoinStorageClass
+  var peernet: Peernet
+  var pubsub: PubSub
+  var globalSub: PubSub
+  var blockStore: LeofcoinStorageClass
+  var transactionStore: LeofcoinStorageClass
+  var messageStore: LeofcoinStorageClass
+  var dataStore: LeofcoinStorageClass
+  var walletStore: LeofcoinStorageClass
+  var chainStore: LeofcoinStorageClass
 }
 
 /**
@@ -37,34 +37,34 @@ declare global {
  * const peernet = new Peernet();
  */
 export default class Peernet {
-  storePrefix: string;
-  root: string;
-  identity: Identity;
-  stores: string[] = [];
-  peerId: string;
+  storePrefix: string
+  root: string
+  identity: Identity
+  stores: string[] = []
+  peerId: string
   /**
    * @type {Object}
    * @property {Object} peer Instance of Peer
    */
-  dht: DHT = new DHT();
+  dht: DHT = new DHT()
   /** @leofcoin/peernet-swarm/client */
-  client: swarm;
-  network: string;
-  stars: string[];
-  networkVersion: string;
+  client: swarm
+  network: string
+  stars: string[]
+  networkVersion: string
   bw: {
-    up: number;
-    down: number;
-  };
-  hasDaemon: boolean = false;
-  autoStart: boolean = true;
-  #starting: boolean = false;
-  #started: boolean = false;
-  #connections: { [index: PeerId]: P2PTPeer } = {};
-  requestProtos = {};
-  _messageHandler: MessageHandler;
-  _peerHandler: PeerDiscovery;
-  protos: {};
+    up: number
+    down: number
+  }
+  hasDaemon: boolean = false
+  autoStart: boolean = true
+  #starting: boolean = false
+  #started: boolean = false
+  #connections: { [index: PeerId]: P2PTPeer } = {}
+  requestProtos = {}
+  _messageHandler: MessageHandler
+  _peerHandler: PeerDiscovery
+  protos: {}
 
   /**
    * @access public
@@ -83,99 +83,77 @@ export default class Peernet {
     /**
      * @property {String} network - current network
      */
-    this.network = options.network || "leofcoin";
-    this.autoStart = options.autoStart === undefined ? true : options.autoStart;
-    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;
+    this.network = options.network || 'leofcoin'
+    this.autoStart = options.autoStart === undefined ? true : options.autoStart
+    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}`);
+      parts[1] ? (options.root = `.${parts[0]}/${parts[1]}`) : (options.root = `.${this.network}`)
     }
 
-    globalThis.peernet = this;
+    globalThis.peernet = this
     this.bw = {
       up: 0,
-      down: 0,
-    };
+      down: 0
+    }
     // @ts-ignore
-    return this._init(options, password);
+    return this._init(options, password)
   }
 
   get id() {
-    return this.identity.id;
+    return this.identity.id
   }
 
   get selectedAccount(): string {
-    return this.identity.selectedAccount;
+    return this.identity.selectedAccount
   }
 
-  get accounts(): Promise<
-    [[name: string, externalAddress: string, internalAddress: string]]
-  > {
-    return this.identity.accounts;
+  get accounts(): Promise<[[name: string, externalAddress: string, internalAddress: string]]> {
+    return this.identity.accounts
   }
 
   get defaultStores() {
-    return [
-      "account",
-      "wallet",
-      "block",
-      "transaction",
-      "chain",
-      "data",
-      "message",
-    ];
+    return ['account', 'wallet', 'block', 'transaction', 'chain', 'data', 'message']
   }
 
   selectAccount(account: string) {
-    return this.identity.selectAccount(account);
+    return this.identity.selectAccount(account)
   }
 
   addProto(name, proto) {
-    if (!globalThis.peernet.protos[name])
-      globalThis.peernet.protos[name] = proto;
+    if (!globalThis.peernet.protos[name]) globalThis.peernet.protos[name] = proto
   }
 
   addCodec(codec) {
-    return codecUtils.addCodec(codec);
+    return codecUtils.addCodec(codec)
   }
 
   async addStore(name, prefix, root, isPrivate = true) {
-    if (
-      name === "block" ||
-      name === "transaction" ||
-      name === "chain" ||
-      name === "data" ||
-      name === "message"
-    )
-      isPrivate = false;
+    if (name === 'block' || name === 'transaction' || name === 'chain' || name === 'data' || name === 'message')
+      isPrivate = false
 
-    let Storage;
+    let Storage
 
-    this.hasDaemon
-      ? (Storage = LeofcoinStorageClient)
-      : (Storage = LeofcoinStorage);
+    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`] = new Storage(name, root)
+      await globalThis[`${name}Store`].init()
     }
 
-    globalThis[`${name}Store`].private = isPrivate;
-    if (!isPrivate) this.stores.push(name);
+    globalThis[`${name}Store`].private = isPrivate
+    if (!isPrivate) this.stores.push(name)
   }
 
   /**
    * @see MessageHandler
    */
   prepareMessage(data) {
-    return this._messageHandler.prepareMessage(data);
+    return this._messageHandler.prepareMessage(data)
   }
 
   /**
@@ -184,22 +162,22 @@ export default class Peernet {
    * @return {Array} peerId
    */
   get peers() {
-    return Object.entries(this.#connections);
+    return Object.entries(this.#connections)
   }
 
   get connections() {
-    return Object.values(this.#connections);
+    return Object.values(this.#connections)
   }
 
   get peerEntries() {
-    return Object.values(this.#connections);
+    return Object.values(this.#connections)
   }
 
   /**
    * @return {String} id - peerId
    */
   getConnection(id) {
-    return this.connections[id];
+    return this.connections[id]
   }
 
   /**
@@ -210,12 +188,9 @@ export default class Peernet {
    *
    * @return {Promise} instance of Peernet
    */
-  async _init(
-    options: { storePrefix?: string; root?: string },
-    password: string
-  ): Promise<Peernet> {
-    this.storePrefix = options.storePrefix;
-    this.root = options.root;
+  async _init(options: { storePrefix?: string; root?: string }, password: string): Promise<Peernet> {
+    this.storePrefix = options.storePrefix
+    this.root = options.root
 
     const {
       RequestMessage,
@@ -229,9 +204,9 @@ export default class Peernet {
       DataMessageResponse,
       PsMessage,
       ChatMessage,
-      PeernetFile,
+      PeernetFile
       // FolderMessageResponse
-    } = await import(/* webpackChunkName: "messages" */ "./messages.js");
+    } = await import(/* webpackChunkName: "messages" */ './messages.js')
 
     /**
      * proto Object containing protos
@@ -244,180 +219,164 @@ export default class Peernet {
      */
 
     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;
+      '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);
+      await this.addStore(store, options.storePrefix, options.root)
     }
 
-    this.identity = new Identity(this.network);
-    await this.identity.load(password);
+    this.identity = new Identity(this.network)
+    await this.identity.load(password)
 
-    this._peerHandler = new PeerDiscovery(this.id);
-    this.peerId = this.id;
+    this._peerHandler = new PeerDiscovery(this.id)
+    this.peerId = this.id
 
-    this.addRequestHandler("handshake", () => {
-      return new peernet.protos["peernet-response"]({
-        response: { peerId: this.id },
-      });
-    });
+    this.addRequestHandler('handshake', () => {
+      return new peernet.protos['peernet-response']({
+        response: { peerId: this.id }
+      })
+    })
 
-    pubsub.subscribe("peer:discovered", async (peer) => {
+    pubsub.subscribe('peer:discovered', async (peer) => {
       // console.log(peer);
 
-      if (this.requestProtos["version"]) {
-        let data = await new globalThis.peernet.protos["peernet-request"]({
-          request: "version",
-        });
-        let node = await globalThis.peernet.prepareMessage(data);
-        let response = await peer.request(node.encoded);
-        response = await new globalThis.peernet.protos["peernet-response"](
-          new Uint8Array(Object.values(response))
-        );
-        peer.version = response.decoded.response.version;
+      if (this.requestProtos['version']) {
+        let data = await new globalThis.peernet.protos['peernet-request']({
+          request: 'version'
+        })
+        let node = await globalThis.peernet.prepareMessage(data)
+        let response = await peer.request(node.encoded)
+        response = await new globalThis.peernet.protos['peernet-response'](new Uint8Array(Object.values(response)))
+        peer.version = response.decoded.response.version
       }
 
-      let data = await new globalThis.peernet.protos["peernet-request"]({
-        request: "handshake",
-      });
-      let node = await globalThis.peernet.prepareMessage(data);
-      let response = await peer.request(node.encoded);
+      let data = await new globalThis.peernet.protos['peernet-request']({
+        request: 'handshake'
+      })
+      let node = await globalThis.peernet.prepareMessage(data)
+      let response = await peer.request(node.encoded)
 
-      response = await new globalThis.peernet.protos["peernet-response"](
-        new Uint8Array(Object.values(response))
-      );
+      response = await new globalThis.peernet.protos['peernet-response'](new Uint8Array(Object.values(response)))
       // todo: response.decoded should be the response and not response.peerId
 
-      this.#connections[response.decoded.response.peerId] = peer;
-      pubsub.publish("peer:connected", peer);
+      this.#connections[response.decoded.response.peerId] = peer
+      pubsub.publish('peer:connected', peer)
       // todo: cleanup discovered
-    });
+    })
 
-    pubsub.subscribe("peer:left", this.#peerLeft.bind(this));
+    pubsub.subscribe('peer:left', this.#peerLeft.bind(this))
 
     /**
      * converts data -> message -> proto
      * @see DataHandler
      */
-    pubsub.subscribe("peer:data", dataHandler);
+    pubsub.subscribe('peer:data', dataHandler)
 
     if (globalThis.navigator) {
-      globalThis.addEventListener("beforeunload", async () =>
-        this.client.destroy()
-      );
+      globalThis.addEventListener('beforeunload', async () => this.client.destroy())
     } else {
-      process.on("SIGTERM", async () => {
-        process.stdin.resume();
+      process.on('SIGTERM', async () => {
+        process.stdin.resume()
         try {
-          await this.client.destroy();
+          await this.client.destroy()
         } catch (error) {
           // @ts-ignore
-          await this.client.close();
+          await this.client.close()
         }
-        process.exit();
-      });
+        process.exit()
+      })
     }
-    if (this.autoStart) await this.start();
-    return this;
+    if (this.autoStart) await this.start()
+    return this
   }
 
   async start() {
-    if (this.#starting || this.#started) return;
+    if (this.#starting || this.#started) return
 
-    this.#starting = true;
-    const importee = await import("@netpeer/p2pt-swarm");
+    this.#starting = true
+    const importee = await import('@netpeer/p2pt-swarm')
     /**
      * @access public
      * @type {PeernetClient}
      */
-    this.client = new importee.default(
-      this.id,
-      this.networkVersion,
-      this.stars
-    );
-    this.#started = true;
-    this.#starting = false;
+    this.client = new importee.default(this.id, this.networkVersion, this.stars)
+    this.#started = true
+    this.#starting = false
   }
 
   #peerLeft(peer: P2PTPeer) {
     for (const [id, _peer] of Object.entries(this.#connections)) {
-      if (
-        _peer.id === peer.id &&
-        this.#connections[id] &&
-        !this.#connections[id].connected
-      ) {
-        delete this.#connections[id];
-        this.removePeer(_peer);
+      if (_peer.id === peer.id && this.#connections[id] && !this.#connections[id].connected) {
+        delete this.#connections[id]
+        this.removePeer(_peer)
       }
     }
   }
 
   addRequestHandler(name, method) {
-    this.requestProtos[name] = method;
+    this.requestProtos[name] = method
   }
 
   async sendMessage(peer, id, data) {
     if (peer.connected) {
-      await peer.send(data, id);
-      this.bw.up += data.length;
-    } else this.removePeer(peer);
+      await peer.send(data, id)
+      this.bw.up += data.length
+    } else this.removePeer(peer)
   }
 
   async handleDHT(peer, id, proto) {
-    let { hash, store } = proto.decoded;
-    let has;
+    let { hash, store } = proto.decoded
+    let has
 
     if (store) {
-      store = globalThis[`${store}Store`];
-      has = store.private ? false : await store.has(hash);
+      store = globalThis[`${store}Store`]
+      has = store.private ? false : await store.has(hash)
     } else {
-      has = await this.has(hash);
+      has = await this.has(hash)
     }
 
-    const data = await new globalThis.peernet.protos["peernet-dht-response"]({
+    const data = await new globalThis.peernet.protos['peernet-dht-response']({
       hash,
-      has,
-    });
-    const node = await this.prepareMessage(data);
+      has
+    })
+    const node = await this.prepareMessage(data)
 
-    this.sendMessage(peer, id, node.encoded);
+    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));
+    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);
+      data = await store.get(hash)
 
       if (data) {
-        data = await new globalThis.peernet.protos["peernet-data-response"]({
+        data = await new globalThis.peernet.protos['peernet-data-response']({
           hash,
-          data,
-        });
+          data
+        })
 
-        const node = await this.prepareMessage(data);
-        this.sendMessage(peer, id, node.encoded);
+        const node = await this.prepareMessage(data)
+        this.sendMessage(peer, id, node.encoded)
       }
     } else {
       // ban (trying to access private st)
@@ -425,11 +384,11 @@ export default class Peernet {
   }
 
   async handleRequest(peer, id, proto) {
-    const method = this.requestProtos[proto.decoded.request];
+    const method = this.requestProtos[proto.decoded.request]
     if (method) {
-      const data = await method(proto.decoded.requested);
-      const node = await this.prepareMessage(data);
-      this.sendMessage(peer, id, node.encoded);
+      const data = await method(proto.decoded.requested)
+      const node = await this.prepareMessage(data)
+      this.sendMessage(peer, id, node.encoded)
     }
   }
 
@@ -440,28 +399,25 @@ export default class Peernet {
    * @param {PeernetPeer} peer - peernet peer
    */
   async _protoHandler(message, peer, from) {
-    const { id, proto } = message;
+    const { id, proto } = message
 
-    this.bw.down += proto.encoded.length;
+    this.bw.down += proto.encoded.length
     switch (proto.name) {
-      case "peernet-dht": {
-        this.handleDHT(peer, id, proto);
-        break;
+      case 'peernet-dht': {
+        this.handleDHT(peer, id, proto)
+        break
       }
-      case "peernet-data": {
-        this.handleData(peer, id, proto);
-        break;
+      case 'peernet-data': {
+        this.handleData(peer, id, proto)
+        break
       }
-      case "peernet-request": {
-        this.handleRequest(peer, id, proto);
-        break;
+      case 'peernet-request': {
+        this.handleRequest(peer, id, proto)
+        break
       }
 
-      case "peernet-ps": {
-        globalSub.publish(
-          new TextDecoder().decode(proto.decoded.topic),
-          proto.decoded.data
-        );
+      case 'peernet-ps': {
+        globalSub.publish(new TextDecoder().decode(proto.decoded.topic), proto.decoded.data)
       }
     }
   }
@@ -472,29 +428,29 @@ export default class Peernet {
    * @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 });
+    if (!hash) throw new Error('hash expected, received undefined')
+    const data = await new globalThis.peernet.protos['peernet-dht']({ hash })
     const walk = async (peer, peerId) => {
-      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);
+      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)
 
       const peerInfo = {
         ...peer.connectionStats,
-        id: peerId,
-      };
+        id: peerId
+      }
 
-      if (proto.decoded.has) this.dht.addProvider(peerInfo, proto.decoded.hash);
-    };
-    let walks = [];
+      if (proto.decoded.has) this.dht.addProvider(peerInfo, proto.decoded.hash)
+    }
+    let walks = []
     for (const [peerId, peer] of Object.entries(this.#connections)) {
       if (peerId !== this.id) {
-        walks.push(walk(peer, peerId));
+        walks.push(walk(peer, peerId))
       }
     }
-    return Promise.all(walks);
+    return Promise.all(walks)
   }
 
   /**
@@ -503,97 +459,92 @@ export default class Peernet {
    * @param {String} hash
    */
   async providersFor(hash: string, store?: undefined) {
-    let providers = this.dht.providersFor(hash);
+    let providers = this.dht.providersFor(hash)
     // walk the network to find a provider
-    let tries = 0;
-    while (
-      (!providers && tries < 3) ||
-      (Object.keys(providers).length === 0 && tries < 3)
-    ) {
-      tries += 1;
-      await this.walk(hash);
-      providers = this.dht.providersFor(hash);
+    let tries = 0
+    while ((!providers && tries < 3) || (Object.keys(providers).length === 0 && tries < 3)) {
+      tries += 1
+      await this.walk(hash)
+      providers = this.dht.providersFor(hash)
     }
     // undefined if no providers given
-    return providers;
+    return providers
   }
 
   get block() {
     return {
       get: async (hash: string) => {
-        const data = await blockStore.has(hash);
-        if (data) return blockStore.get(hash);
-        return this.requestData(hash, "block");
+        const data = await blockStore.has(hash)
+        if (data) return blockStore.get(hash)
+        return this.requestData(hash, 'block')
       },
       put: async (hash: string, data: Uint8Array) => {
-        if (await blockStore.has(hash)) return;
-        return await blockStore.put(hash, data);
+        if (await blockStore.has(hash)) return
+        return await blockStore.put(hash, data)
       },
-      has: async (hash: string) => await blockStore.has(hash),
-    };
+      has: async (hash: string) => await blockStore.has(hash)
+    }
   }
 
   get transaction() {
     return {
       get: async (hash: string) => {
-        const data = await transactionStore.has(hash);
-        if (data) return await transactionStore.get(hash);
-        return this.requestData(hash, "transaction");
+        const data = await transactionStore.has(hash)
+        if (data) return await transactionStore.get(hash)
+        return this.requestData(hash, 'transaction')
       },
       put: async (hash: string, data: Uint8Array) => {
-        if (await transactionStore.has(hash)) return;
-        return await transactionStore.put(hash, data);
+        if (await transactionStore.has(hash)) return
+        return await transactionStore.put(hash, data)
       },
-      has: async (hash: string) => await transactionStore.has(hash),
-    };
+      has: async (hash: string) => await transactionStore.has(hash)
+    }
   }
 
   async requestData(hash, store) {
-    const providers = await this.providersFor(hash);
-    if (!providers || (providers && Object.keys(providers).length === 0))
-      throw nothingFoundError(hash);
-    debug(`found ${Object.keys(providers).length} provider(s) for ${hash}`);
+    const providers = await this.providersFor(hash)
+    if (!providers || (providers && Object.keys(providers).length === 0)) throw nothingFoundError(hash)
+    debug(`found ${Object.keys(providers).length} provider(s) for ${hash}`)
     // get closest peer on earth
-    const closestPeer: DHTProvider = Object.values(providers)[0];
+    const closestPeer: DHTProvider = Object.values(providers)[0]
 
     // get peer instance by id
-    if (!closestPeer || !closestPeer.id)
-      return this.requestData(hash, store?.name || store);
+    if (!closestPeer || !closestPeer.id) return this.requestData(hash, store?.name || store)
 
-    const id = closestPeer.id;
-    const peer = this.#connections[id];
+    const id = closestPeer.id
+    const peer = this.#connections[id]
 
     if (peer?.connected) {
-      let data = await new globalThis.peernet.protos["peernet-data"]({
+      let data = await new globalThis.peernet.protos['peernet-data']({
         hash,
-        store: store?.name || store,
-      });
+        store: store?.name || store
+      })
 
-      const node = await this.prepareMessage(data);
+      const node = await this.prepareMessage(data)
 
-      if (peer) data = await peer.request(node.encoded);
+      if (peer) data = await peer.request(node.encoded)
       else {
         // fallback and try every provider found
-        const promises = [];
-        const providers = await this.providersFor(hash, store);
+        const promises = []
+        const providers = await this.providersFor(hash, store)
         for (const provider of Object.values(providers)) {
-          const peer = this.#connections[provider.id];
+          const peer = this.#connections[provider.id]
 
-          if (peer) promises.push(peer.request(node.encoded));
+          if (peer) promises.push(peer.request(node.encoded))
         }
-        data = await Promise.race(promises);
+        data = await Promise.race(promises)
       }
-      if (data) data = new Uint8Array(Object.values(data));
+      if (data) data = new Uint8Array(Object.values(data))
 
-      const proto = await protoFor(data);
+      const proto = await protoFor(data)
       // TODO: store data automaticly or not
-      return BufferToUint8Array(proto.decoded.data);
+      return BufferToUint8Array(proto.decoded.data)
 
       // this.put(hash, proto.decoded.data)
     } else {
-      this.dht.removeProvider(id, hash);
+      this.dht.removeProvider(id, hash)
     }
-    return;
+    return
   }
 
   get message() {
@@ -604,10 +555,10 @@ export default class Peernet {
        * @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");
+        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
@@ -620,8 +571,8 @@ export default class Peernet {
        * @param {String} hash
        * @return {Boolean}
        */
-      has: async (hash) => await messageStore.has(hash),
-    };
+      has: async (hash) => await messageStore.has(hash)
+    }
   }
 
   get data() {
@@ -632,10 +583,10 @@ export default class Peernet {
        * @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");
+        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
@@ -648,8 +599,8 @@ export default class Peernet {
        * @param {String} hash
        * @return {Boolean}
        */
-      has: async (hash) => await dataStore.has(hash),
-    };
+      has: async (hash) => await dataStore.has(hash)
+    }
   }
 
   get folder() {
@@ -660,10 +611,10 @@ export default class Peernet {
        * @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");
+        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
@@ -676,61 +627,54 @@ export default class Peernet {
        * @param {String} hash
        * @return {Boolean}
        */
-      has: async (hash) => await dataStore.has(hash),
-    };
+      has: async (hash) => await dataStore.has(hash)
+    }
   }
 
   async addFolder(files) {
-    const links = [];
+    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 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);
+    const node = await new globalThis.peernet.protos['peernet-file']({
+      path: '/',
+      links
+    })
+    const hash = await node.hash
+    await dataStore.put(hash, node.encoded)
 
-    return hash;
+    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`);
+    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 });
+      paths.push({ path, hash })
     }
-    if (options?.pin) await dataStore.put(hash, node.encoded);
-    return paths;
+    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);
+    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;
+    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
   }
 
   /**
@@ -739,14 +683,14 @@ export default class Peernet {
    * @param {string} hash
    */
   async whichStore(stores, hash) {
-    let store = stores.pop();
-    const name = store;
-    store = globalThis[`${store}Store`];
+    let store = stores.pop()
+    const name = store
+    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;
+      const has = await store.has(hash)
+      if (has) return store
+      if (stores.length > 0) return this.whichStore(stores, hash)
+    } else return
   }
 
   /**
@@ -756,14 +700,14 @@ export default class Peernet {
    * @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;
+    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);
+    return this.requestData(hash, store?.name || store)
   }
 
   /**
@@ -773,13 +717,9 @@ export default class Peernet {
    * @param {Buffer} data
    * @param {String} storeName - storeName to access
    */
-  async put(
-    hash: string,
-    data: Uint8Array,
-    storeName: string | LeofcoinStorageClass = "data"
-  ) {
-    const store: LeofcoinStorageClass = globalThis[`${storeName}Store`];
-    return store.put(hash, data);
+  async put(hash: string, data: Uint8Array, storeName: string | LeofcoinStorageClass = 'data') {
+    const store: LeofcoinStorageClass = globalThis[`${storeName}Store`]
+    return store.put(hash, data)
   }
 
   /**
@@ -787,11 +727,11 @@ export default class Peernet {
    * @return {Boolean}
    */
   async has(hash) {
-    const store = await this.whichStore([...this.stores], hash);
+    const store = await this.whichStore([...this.stores], hash)
     if (store) {
-      return store.private ? false : true;
+      return store.private ? false : true
     }
-    return false;
+    return false
   }
 
   /**
@@ -801,12 +741,12 @@ export default class Peernet {
    */
   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 });
+    const id = Math.random().toString(36).slice(-12)
+    data = await new globalThis.peernet.protos['peernet-ps']({ data, topic })
     for (const [peerId, peer] of Object.entries(this.#connections)) {
       if (peerId !== this.id) {
-        const node = await this.prepareMessage(data);
-        this.sendMessage(peer, id, node.encoded);
+        const node = await this.prepareMessage(data)
+        this.sendMessage(peer, id, node.encoded)
       }
       // TODO: if peer subscribed
     }
@@ -823,26 +763,25 @@ export default class Peernet {
    */
   async subscribe(topic: string, callback: Function) {
     // TODO: if peer subscribed
-    globalSub.subscribe(topic, callback);
+    globalSub.subscribe(topic, callback)
   }
 
   async removePeer(peer) {
-    console.log("removepeer", peer.id);
-    const id = peer.id;
-    await this.client._removePeer(peer);
+    console.log('removepeer', peer.id)
+    const id = peer.id
+    await this.client._removePeer(peer)
     if (this.client.peers[id]) {
       for (const connection of Object.keys(this.client.peers[id])) {
         // if (this.client.peers[id][connection].connected === false) delete this.client.peers[id][connection]
         // @ts-ignore
-        if (this.client.peers[id][connection].connected)
-          return this.client.emit("peerconnect", connection);
+        if (this.client.peers[id][connection].connected) return this.client.emit('peerconnect', connection)
       }
     }
   }
 
   get Buffer() {
-    return Buffer;
+    return Buffer
   }
 }
 
-globalThis.Peernet = Peernet;
+globalThis.Peernet = Peernet