@leofcoin/peernet 1.1.56 → 1.1.58

package/exports/peernet.js

@@ -9,140 +9,140 @@ import { decrypt } from '@leofcoin/identity-utils';
 import QrScanner from 'qr-scanner';
 import qrcode from 'qrcode';
 
-const BufferToUint8Array = data => {
-  if (data.type === 'Buffer') {
-    data = new Uint8Array(data.data);
-  }
-  return data
+const BufferToUint8Array = 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)
+};
+
+/**
+ * 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
+  }
+};
+
+const 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'
+  }
+};
+
+/**
+ * * Get current environment
+ * @return {Object} result
+ * @property {Boolean} reult.daemon whether or not daemon is running
+ * @property {Boolean} reult.environment Current environment
+ */
+const target = async () => {
+  let daemon = false;
+  if (!https()) daemon = await hasDaemon();
+
+  return {daemon, environment: environment()}
 };
 
-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)
-};
-
-/**
- * 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
-  }
-};
-
-const 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'
-  }
-};
-
-/**
- * * Get current environment
- * @return {Object} result
- * @property {Boolean} reult.daemon whether or not daemon is running
- * @property {Boolean} reult.environment Current environment
- */
-const target = async () => {
-  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);
-        }
-      }
-      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);
-        }
-      }
-    }
-  }
+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);
+        }
+      }
+      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);
+        }
+      }
+    }
+  }
 }
 
 /**
@@ -252,62 +252,63 @@ class DhtEarth {
     }
 }
 
-class MessageHandler {
-  constructor(network) {
-    this.network = network;
-  }
-  /**
-   * hash and sign message
-   *
-   * @param {object} message
-   * @param {Buffer} message.from peer id
-   * @param {Buffer} message.to peer id
-   * @param {string} message.data Peernet message
-   * (PeernetMessage excluded) encoded as a string
-   * @return message
-   */
-  async hashAndSignMessage(message) {
-    const hash = await message.peernetHash;
-    message.decoded.signature = globalThis.identity.sign(hash.buffer);
-    return message
-  }
-
-  /**
-   * @param {String} from - peer id
-   * @param {String} to - peer id
-   * @param {String|PeernetMessage} data - data encoded message string
-   * or the messageNode itself
-   */
-  async prepareMessage(message) {    
-    if (message.keys.includes('signature')) {
-      message = await this.hashAndSignMessage(message);
-    }
-
-    return message
-  }
+class MessageHandler {
+  constructor(network) {
+    this.network = network;
+  }
+  /**
+   * hash and sign message
+   *
+   * @param {object} message
+   * @param {Buffer} message.from peer id
+   * @param {Buffer} message.to peer id
+   * @param {string} message.data Peernet message
+   * (PeernetMessage excluded) encoded as a string
+   * @return message
+   */
+  async hashAndSignMessage(message) {
+    const hash = await message.peernetHash;
+    message.decoded.signature = globalThis.identity.sign(hash.buffer);
+    return message
+  }
+
+  /**
+   * @param {String} from - peer id
+   * @param {String} to - peer id
+   * @param {String|PeernetMessage} data - data encoded message string
+   * or the messageNode itself
+   */
+  async prepareMessage(message) {    
+    if (message.keys.includes('signature')) {
+      message = await this.hashAndSignMessage(message);
+    }
+
+    return message
+  }
 }
 
-const dataHandler = async message => {
-  if (!message) return
-
-  const {data, id, from, peer} = message;
-  const proto = await protoFor(data);
-  peernet._protoHandler({id, proto}, peernet.connections[from] || peer, from);
-};
-
-const dhtError = (proto) => {
-  const text = `Received proto ${proto.name} expected peernet-dht-response`;
-  return new Error(`Routing error: ${text}`)
+const dataHandler = async message => {
+  if (!message) return
+
+  const {data, id, from, peer} = message;
+  const proto = await protoFor(data);
+  peernet._protoHandler({id, proto}, peernet.connections[from] || peer, from);
 };
 
-const 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}`)
 };
 
 class Identity {
     #wallet;
     network;
     id;
+    selectedAccount;
     constructor(network) {
         this.network = network;
     }
@@ -330,6 +331,7 @@ class Identity {
             }
         }
         if (!password) {
+            // @ts-ignore
             const importee = await import('./src/prompts/password.js');
             password = await importee.default();
         }
@@ -338,7 +340,7 @@ class Identity {
             const pub = await globalThis.accountStore.get('public');
             this.id = JSON.parse(new TextDecoder().decode(pub)).walletId;
             const selected = await globalThis.walletStore.get('selected-account');
-            globalThis.peernet.selectedAccount = new TextDecoder().decode(selected);
+            this.selectedAccount = new TextDecoder().decode(selected);
         }
         else {
             const importee = await import(/* webpackChunkName: "generate-account" */ '@leofcoin/generate-account');
@@ -348,7 +350,7 @@ class Identity {
             await globalThis.walletStore.put('accounts', JSON.stringify(accounts));
             await globalThis.walletStore.put('selected-account', accounts[0][1]);
             await globalThis.walletStore.put('identity', JSON.stringify(identity));
-            globalThis.peernet.selectedAccount = accounts[0][1];
+            this.selectedAccount = accounts[0][1];
             this.id = identity.walletId;
         }
         const identity = JSON.parse(new TextDecoder().decode(await globalThis.walletStore.get('identity')));
@@ -356,6 +358,10 @@ class Identity {
         const multiWIF = await decrypt(password, base58.decode(identity.multiWIF));
         await this.#wallet.fromMultiWif(multiWIF);
     }
+    selectAccount(account) {
+        this.selectedAccount = account;
+        return walletStore.put('selected-account', account);
+    }
     sign(hash) {
         return this.#wallet.sign(hash.subarray(0, 32));
     }
@@ -376,7 +382,7 @@ class Identity {
         return globalThis.navigator ? await qrcode.toDataURL(exported) : await qrcode.toString(exported, { type: 'terminal' });
     }
     async importQR(image, password) {
-        const multiWIF = QrScanner.scanImage(image);
+        const multiWIF = await QrScanner.default.scanImage(image);
         return this.import(password, multiWIF);
     }
 }
@@ -433,17 +439,20 @@ class Peernet {
         /**
          * @property {String} network - current network
          */
-        this.network = options.network || 'leofcoin';
+        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';
+        const parts = this.network.split(":");
+        this.networkVersion =
+            options.networkVersion || parts.length > 1 ? parts[1] : "mainnet";
         if (!options.storePrefix)
-            options.storePrefix = 'lfc';
+            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;
         this.bw = {
@@ -456,11 +465,25 @@ class Peernet {
     get id() {
         return this.identity.id;
     }
+    get selectedAccount() {
+        return this.identity.selectedAccount;
+    }
     get accounts() {
         return this.identity.accounts;
     }
     get defaultStores() {
-        return ['account', 'wallet', 'block', 'transaction', 'chain', 'data', 'message'];
+        return [
+            "account",
+            "wallet",
+            "block",
+            "transaction",
+            "chain",
+            "data",
+            "message",
+        ];
+    }
+    selectAccount(account) {
+        return this.identity.selectAccount(account);
     }
     addProto(name, proto) {
         if (!globalThis.peernet.protos[name])
@@ -470,11 +493,16 @@ class Peernet {
         return utils.addCodec(codec);
     }
     async addStore(name, prefix, root, isPrivate = true) {
-        if (name === 'block' || name === 'transaction' || name === 'chain' ||
-            name === 'data' || name === 'message')
+        if (name === "block" ||
+            name === "transaction" ||
+            name === "chain" ||
+            name === "data" ||
+            name === "message")
             isPrivate = false;
         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();
@@ -507,7 +535,7 @@ class Peernet {
      * @return {String} id - peerId
      */
     getConnection(id) {
-        return this.client.connections[id];
+        return this.connections[id];
     }
     /**
      * @private
@@ -520,9 +548,9 @@ class Peernet {
     async _init(options, password) {
         this.storePrefix = options.storePrefix;
         this.root = options.root;
-        const { RequestMessage, ResponseMessage, PeerMessage, PeerMessageResponse, PeernetMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PsMessage, ChatMessage, PeernetFile
+        const { RequestMessage, ResponseMessage, PeerMessage, PeerMessageResponse, PeernetMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PsMessage, ChatMessage, PeernetFile,
         // FolderMessageResponse
-         } = await import(/* webpackChunkName: "messages" */ './messages-dc960cb3.js');
+         } = await import(/* webpackChunkName: "messages" */ './messages-b9a32987.js');
         /**
          * proto Object containing protos
          * @type {Object}
@@ -533,18 +561,18 @@ class Peernet {
          * @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
+            "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();
@@ -556,38 +584,44 @@ class Peernet {
         await this.identity.load(password);
         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' });
+            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)));
+                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 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);
+            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.on("SIGTERM", async () => {
                 process.stdin.resume();
                 try {
                     await this.client.destroy();
@@ -618,7 +652,9 @@ class Peernet {
     }
     #peerLeft(peer) {
         for (const [id, _peer] of Object.entries(this.#connections)) {
-            if (_peer.id === peer.id && this.#connections[id] && !this.#connections[id].connected) {
+            if (_peer.id === peer.id &&
+                this.#connections[id] &&
+                !this.#connections[id].connected) {
                 delete this.#connections[id];
                 this.removePeer(_peer);
             }
@@ -645,18 +681,26 @@ class Peernet {
         else {
             has = await this.has(hash);
         }
-        const data = await new globalThis.peernet.protos['peernet-dht-response']({ hash, has });
+        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);
+        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 });
+                data = await new globalThis.peernet.protos["peernet-data-response"]({
+                    hash,
+                    data,
+                });
                 const node = await this.prepareMessage(data);
                 this.sendMessage(peer, id, node.encoded);
             }
@@ -680,21 +724,20 @@ class Peernet {
         const { id, proto } = message;
         this.bw.down += proto.encoded.length;
         switch (proto.name) {
-            case 'peernet-dht': {
+            case "peernet-dht": {
                 this.handleDHT(peer, id, proto);
                 break;
             }
-            case 'peernet-data': {
+            case "peernet-data": {
                 this.handleData(peer, id, proto);
                 break;
             }
-            case 'peernet-request': {
+            case "peernet-request": {
                 this.handleRequest(peer, id, proto);
                 break;
             }
-            case 'peernet-ps': {
-                if (peer.peerId !== this.id)
-                    globalSub.publish(proto.decoded.topic, proto.decoded.data);
+            case "peernet-ps": {
+                globalSub.publish(new TextDecoder().decode(proto.decoded.topic), proto.decoded.data);
             }
         }
     }
@@ -705,14 +748,14 @@ class Peernet {
      */
     async walk(hash) {
         if (!hash)
-            throw new Error('hash expected, received undefined');
-        const data = await new globalThis.peernet.protos['peernet-dht']({ 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')
+            if (proto.name !== "peernet-dht-response")
                 throw dhtError(proto.name);
             const peerInfo = {
                 ...peer.connectionStats,
@@ -738,7 +781,8 @@ class Peernet {
         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) {
+        while ((!providers && tries < 3) ||
+            (Object.keys(providers).length === 0 && tries < 3)) {
             tries += 1;
             await this.walk(hash);
             providers = this.dht.providersFor(hash);
@@ -752,14 +796,14 @@ class Peernet {
                 const data = await blockStore.has(hash);
                 if (data)
                     return blockStore.get(hash);
-                return this.requestData(hash, 'block');
+                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'),
+            has: async (hash) => await blockStore.has(hash),
         };
     }
     get transaction() {
@@ -768,7 +812,7 @@ class Peernet {
                 const data = await transactionStore.has(hash);
                 if (data)
                     return await transactionStore.get(hash);
-                return this.requestData(hash, 'transaction');
+                return this.requestData(hash, "transaction");
             },
             put: async (hash, data) => {
                 if (await transactionStore.has(hash))
@@ -780,7 +824,7 @@ class Peernet {
     }
     async requestData(hash, store) {
         const providers = await this.providersFor(hash);
-        if (!providers || providers && Object.keys(providers).length === 0)
+        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
@@ -791,7 +835,10 @@ class Peernet {
         const id = closestPeer.id;
         const peer = this.#connections[id];
         if (peer?.connected) {
-            let data = await new globalThis.peernet.protos['peernet-data']({ hash, store: store?.name || store });
+            let data = await new globalThis.peernet.protos["peernet-data"]({
+                hash,
+                store: store?.name || store,
+            });
             const node = await this.prepareMessage(data);
             if (peer)
                 data = await peer.request(node.encoded);
@@ -830,7 +877,7 @@ class Peernet {
                 const message = await messageStore.has(hash);
                 if (message)
                     return await messageStore.get(hash);
-                return this.requestData(hash, 'message');
+                return this.requestData(hash, "message");
             },
             /**
              * put message content
@@ -858,7 +905,7 @@ class Peernet {
                 const data = await dataStore.has(hash);
                 if (data)
                     return await dataStore.get(hash);
-                return this.requestData(hash, 'data');
+                return this.requestData(hash, "data");
             },
             /**
              * put data content
@@ -886,7 +933,7 @@ class Peernet {
                 const data = await dataStore.has(hash);
                 if (data)
                     return await dataStore.get(hash);
-                return this.requestData(hash, 'data');
+                return this.requestData(hash, "data");
             },
             /**
              * put data content
@@ -905,12 +952,15 @@ class Peernet {
     async addFolder(files) {
         const links = [];
         for (const file of files) {
-            const fileNode = await new globalThis.peernet.protos['peernet-file'](file);
+            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 node = await new globalThis.peernet.protos["peernet-file"]({
+            path: "/",
+            links,
+        });
         const hash = await node.hash;
         await dataStore.put(hash, node.encoded);
         return hash;
@@ -918,8 +968,10 @@ class Peernet {
     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);
+        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 = [];
@@ -935,8 +987,10 @@ class Peernet {
     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);
+        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)
@@ -974,7 +1028,7 @@ class Peernet {
             store = globalThis[`${store}Store`];
         if (!store)
             store = await this.whichStore([...this.stores], hash);
-        if (store && await store.has(hash))
+        if (store && (await store.has(hash)))
             data = await store.get(hash);
         if (data)
             return data;
@@ -987,7 +1041,7 @@ class Peernet {
      * @param {Buffer} data
      * @param {String} storeName - storeName to access
      */
-    async put(hash, data, storeName = 'data') {
+    async put(hash, data, storeName = "data") {
         const store = globalThis[`${storeName}Store`];
         return store.put(hash, data);
     }
@@ -1010,7 +1064,7 @@ 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 });
+        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);
@@ -1032,7 +1086,7 @@ class Peernet {
         globalSub.subscribe(topic, callback);
     }
     async removePeer(peer) {
-        console.log('removepeer', peer.id);
+        console.log("removepeer", peer.id);
         const id = peer.id;
         await this.client._removePeer(peer);
         if (this.client.peers[id]) {
@@ -1040,7 +1094,7 @@ class Peernet {
                 // 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);
+                    return this.client.emit("peerconnect", connection);
             }
         }
     }