@leofcoin/peernet 1.2.10 → 1.2.12

package/exports/browser/{client-CwKuEJRO.js → client-DN_Y7L6h.js}

@@ -1,4 +1,4 @@
-import { L as LittlePubSub, d as deflate_1, i as inflate_1, c as createDebugger } from './peernet-CCZ65IdF.js';
+import { L as LittlePubSub, d as deflate_1, i as inflate_1, c as createDebugger } from './peernet-BpKdfmda.js';
 import './identity-CqSnKXWH.js';
 import './value-C3vAp-wb.js';
 

package/exports/browser/{messages-odneBhMk.js → messages-C-BwUsHC.js}

@@ -1,4 +1,4 @@
-import { F as FormatInterface } from './peernet-CCZ65IdF.js';
+import { F as FormatInterface } from './peernet-BpKdfmda.js';
 import './identity-CqSnKXWH.js';
 import './value-C3vAp-wb.js';
 

package/exports/browser/{peernet-CCZ65IdF.js → peernet-BpKdfmda.js}

@@ -8473,7 +8473,7 @@ class Peernet {
         await getAddress();
         this.storePrefix = options.storePrefix;
         this.root = options.root;
-        const { RequestMessage, ResponseMessage, PeerMessage, PeerMessageResponse, PeernetMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PsMessage, ChatMessage, PeernetFile } = await import(/* webpackChunkName: "messages" */ './messages-odneBhMk.js');
+        const { RequestMessage, ResponseMessage, PeerMessage, PeerMessageResponse, PeernetMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PsMessage, ChatMessage, PeernetFile } = await import(/* webpackChunkName: "messages" */ './messages-C-BwUsHC.js');
         /**
          * proto Object containing protos
          * @type {Object}
@@ -8520,7 +8520,7 @@ class Peernet {
         if (this.#starting || this.#started)
             return;
         this.#starting = true;
-        const importee = await import('./client-CwKuEJRO.js');
+        const importee = await import('./client-DN_Y7L6h.js');
         /**
          * @access public
          * @type {PeernetClient}
@@ -8740,7 +8740,9 @@ class Peernet {
                 walks.push(walk(peer, peerId));
             }
         }
-        return Promise.race(walks);
+        // walk the network and return first result.
+        // not waiting for all walks to finish, this is faster and more efficient
+        return Promise.any(walks);
     }
     /**
      * Override DHT behavior, try's finding the content three times
@@ -8792,74 +8794,80 @@ class Peernet {
         };
     }
     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}`);
-        // get closest peer on earth
-        let closestPeer = await this.dht.closestPeer(Object.values(providers));
-        // fallback to first provider if no closest peer found
-        if (!closestPeer || !closestPeer.id)
-            closestPeer = Object.values(providers)[0];
-        debug(`closest peer for ${hash} is ${closestPeer?.address}`);
-        // get peer instance by id
-        if (!closestPeer || !closestPeer.id || !closestPeer.address)
-            return undefined;
-        const id = closestPeer.id;
-        const peer = this.connections[id];
-        if (!peer || !peer?.connected) {
-            this.dht.removeProvider(id, hash);
-            return this.requestData(hash, 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?.connected) {
-            try {
-                if (peer)
-                    data = await peer.request(node.encoded);
-                else {
-                    // fallback and try every provider found
-                    const promises = [];
-                    const providers = await this.providersFor(hash, store);
-                    for (const provider of Object.values(providers)) {
-                        const peer = this.connections[provider.id];
-                        if (peer)
-                            promises.push(peer.request(node.encoded));
+        try {
+            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
+            let closestPeer = await this.dht.closestPeer(Object.values(providers));
+            // fallback to first provider if no closest peer found
+            if (!closestPeer || !closestPeer.id)
+                closestPeer = Object.values(providers)[0];
+            debug(`closest peer for ${hash} is ${closestPeer?.address}`);
+            // get peer instance by id
+            if (!closestPeer || !closestPeer.id || !closestPeer.address)
+                return undefined;
+            const id = closestPeer.id;
+            const peer = this.connections[id];
+            if (!peer || !peer?.connected) {
+                this.dht.removeProvider(id, hash);
+                return this.requestData(hash, 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?.connected) {
+                try {
+                    if (peer)
+                        data = await peer.request(node.encoded);
+                    else {
+                        // fallback and try every provider found
+                        const promises = [];
+                        const providers = await this.providersFor(hash, store);
+                        for (const provider of Object.values(providers)) {
+                            const peer = this.connections[provider.id];
+                            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.length === 0)
+                        throw nothingFoundError(hash);
+                    const proto = await protoFor(data);
+                    // TODO: store data automaticly or not
+                    return BufferToUint8Array(proto.decoded.data);
                 }
-                if (data)
-                    data = new Uint8Array(Object.values(data));
-                if (!data || data.length === 0)
-                    throw nothingFoundError(hash);
-                const proto = await protoFor(data);
-                // TODO: store data automaticly or not
-                return BufferToUint8Array(proto.decoded.data);
-            }
-            catch (error) {
-                debug(`Error while requesting data from ${id}`, error);
-                // if error, remove provider
-                if (this.#peerAttempts[id] > 1) {
-                    this.#peerAttempts[id] = 0;
-                    debug(`Removed provider ${id} for ${hash} after 3 attempts`);
-                    this.dht.removeProvider(id, hash);
-                    console.error(nothingFoundError(hash));
-                    return undefined;
+                catch (error) {
+                    debug(`Error while requesting data from ${id}`, error);
+                    // if error, remove provider
+                    if (this.#peerAttempts[id] > 1) {
+                        this.#peerAttempts[id] = 0;
+                        debug(`Removed provider ${id} for ${hash} after 3 attempts`);
+                        this.dht.removeProvider(id, hash);
+                        console.error(nothingFoundError(hash));
+                        return undefined;
+                    }
+                    if (this.#peerAttempts[id] === undefined)
+                        this.#peerAttempts[id] = 0;
+                    this.#peerAttempts[id]++;
+                    return this.requestData(hash, store?.name || store);
                 }
-                if (this.#peerAttempts[id] === undefined)
-                    this.#peerAttempts[id] = 0;
-                this.#peerAttempts[id]++;
-                return this.requestData(hash, store?.name || store);
+                // this.put(hash, proto.decoded.data)
+            }
+            else {
+                this.dht.removeProvider(id, hash);
             }
-            // this.put(hash, proto.decoded.data)
+            return undefined;
         }
-        else {
-            this.dht.removeProvider(id, hash);
+        catch (error) {
+            console.error(`Error while requesting data for ${hash} from the network`, error);
+            return undefined;
         }
-        return;
     }
     get message() {
         return {
@@ -8959,7 +8967,7 @@ class Peernet {
                 const data = await shareStore.has(hash);
                 if (data)
                     return await shareStore.get(hash);
-                return undefined;
+                return this.requestData(hash, 'share');
             },
             /**
              * put share content

package/exports/browser/peernet.js

@@ -1,3 +1,3 @@
-export { P as default } from './peernet-CCZ65IdF.js';
+export { P as default } from './peernet-BpKdfmda.js';
 import './identity-CqSnKXWH.js';
 import './value-C3vAp-wb.js';

package/exports/peernet.js

@@ -718,7 +718,9 @@ class Peernet {
                 walks.push(walk(peer, peerId));
             }
         }
-        return Promise.race(walks);
+        // walk the network and return first result.
+        // not waiting for all walks to finish, this is faster and more efficient
+        return Promise.any(walks);
     }
     /**
      * Override DHT behavior, try's finding the content three times
@@ -770,74 +772,80 @@ class Peernet {
         };
     }
     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}`);
-        // get closest peer on earth
-        let closestPeer = await this.dht.closestPeer(Object.values(providers));
-        // fallback to first provider if no closest peer found
-        if (!closestPeer || !closestPeer.id)
-            closestPeer = Object.values(providers)[0];
-        debug(`closest peer for ${hash} is ${closestPeer?.address}`);
-        // get peer instance by id
-        if (!closestPeer || !closestPeer.id || !closestPeer.address)
-            return undefined;
-        const id = closestPeer.id;
-        const peer = this.connections[id];
-        if (!peer || !peer?.connected) {
-            this.dht.removeProvider(id, hash);
-            return this.requestData(hash, 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?.connected) {
-            try {
-                if (peer)
-                    data = await peer.request(node.encoded);
-                else {
-                    // fallback and try every provider found
-                    const promises = [];
-                    const providers = await this.providersFor(hash, store);
-                    for (const provider of Object.values(providers)) {
-                        const peer = this.connections[provider.id];
-                        if (peer)
-                            promises.push(peer.request(node.encoded));
+        try {
+            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
+            let closestPeer = await this.dht.closestPeer(Object.values(providers));
+            // fallback to first provider if no closest peer found
+            if (!closestPeer || !closestPeer.id)
+                closestPeer = Object.values(providers)[0];
+            debug(`closest peer for ${hash} is ${closestPeer?.address}`);
+            // get peer instance by id
+            if (!closestPeer || !closestPeer.id || !closestPeer.address)
+                return undefined;
+            const id = closestPeer.id;
+            const peer = this.connections[id];
+            if (!peer || !peer?.connected) {
+                this.dht.removeProvider(id, hash);
+                return this.requestData(hash, 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?.connected) {
+                try {
+                    if (peer)
+                        data = await peer.request(node.encoded);
+                    else {
+                        // fallback and try every provider found
+                        const promises = [];
+                        const providers = await this.providersFor(hash, store);
+                        for (const provider of Object.values(providers)) {
+                            const peer = this.connections[provider.id];
+                            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.length === 0)
+                        throw nothingFoundError(hash);
+                    const proto = await protoFor(data);
+                    // TODO: store data automaticly or not
+                    return BufferToUint8Array(proto.decoded.data);
                 }
-                if (data)
-                    data = new Uint8Array(Object.values(data));
-                if (!data || data.length === 0)
-                    throw nothingFoundError(hash);
-                const proto = await protoFor(data);
-                // TODO: store data automaticly or not
-                return BufferToUint8Array(proto.decoded.data);
-            }
-            catch (error) {
-                debug(`Error while requesting data from ${id}`, error);
-                // if error, remove provider
-                if (this.#peerAttempts[id] > 1) {
-                    this.#peerAttempts[id] = 0;
-                    debug(`Removed provider ${id} for ${hash} after 3 attempts`);
-                    this.dht.removeProvider(id, hash);
-                    console.error(nothingFoundError(hash));
-                    return undefined;
+                catch (error) {
+                    debug(`Error while requesting data from ${id}`, error);
+                    // if error, remove provider
+                    if (this.#peerAttempts[id] > 1) {
+                        this.#peerAttempts[id] = 0;
+                        debug(`Removed provider ${id} for ${hash} after 3 attempts`);
+                        this.dht.removeProvider(id, hash);
+                        console.error(nothingFoundError(hash));
+                        return undefined;
+                    }
+                    if (this.#peerAttempts[id] === undefined)
+                        this.#peerAttempts[id] = 0;
+                    this.#peerAttempts[id]++;
+                    return this.requestData(hash, store?.name || store);
                 }
-                if (this.#peerAttempts[id] === undefined)
-                    this.#peerAttempts[id] = 0;
-                this.#peerAttempts[id]++;
-                return this.requestData(hash, store?.name || store);
+                // this.put(hash, proto.decoded.data)
+            }
+            else {
+                this.dht.removeProvider(id, hash);
             }
-            // this.put(hash, proto.decoded.data)
+            return undefined;
         }
-        else {
-            this.dht.removeProvider(id, hash);
+        catch (error) {
+            console.error(`Error while requesting data for ${hash} from the network`, error);
+            return undefined;
         }
-        return;
     }
     get message() {
         return {
@@ -937,7 +945,7 @@ class Peernet {
                 const data = await shareStore.has(hash);
                 if (data)
                     return await shareStore.get(hash);
-                return undefined;
+                return this.requestData(hash, 'share');
             },
             /**
              * put share content

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/peernet",
-  "version": "1.2.10",
+  "version": "1.2.12",
   "description": "",
   "browser": "./exports/browser/peernet.js",
   "exports": {

package/src/peernet.ts

@@ -505,7 +505,9 @@ export default class Peernet {
         walks.push(walk(peer, peerId))
       }
     }
-    return Promise.race(walks)
+    // walk the network and return first result.
+    // not waiting for all walks to finish, this is faster and more efficient
+    return Promise.any(walks)
   }
 
   /**
@@ -557,73 +559,78 @@ export default class Peernet {
   }
 
   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}`)
-    // get closest peer on earth
-    let closestPeer: DHTProvider = await this.dht.closestPeer(Object.values(providers))
-    // fallback to first provider if no closest peer found
-    if (!closestPeer || !closestPeer.id) closestPeer = Object.values(providers)[0]
-
-    debug(`closest peer for ${hash} is ${closestPeer?.address}`)
-    // get peer instance by id
-    if (!closestPeer || !closestPeer.id || !closestPeer.address) return undefined
-    const id = closestPeer.id
-    const peer = this.connections[id]
-
-    if (!peer || !peer?.connected) {
-      this.dht.removeProvider(id, hash)
-      return this.requestData(hash, store?.name || store)
-    }
+    try {
+      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
+      let closestPeer: DHTProvider = await this.dht.closestPeer(Object.values(providers))
+      // fallback to first provider if no closest peer found
+      if (!closestPeer || !closestPeer.id) closestPeer = Object.values(providers)[0]
+
+      debug(`closest peer for ${hash} is ${closestPeer?.address}`)
+      // get peer instance by id
+      if (!closestPeer || !closestPeer.id || !closestPeer.address) return undefined
+      const id = closestPeer.id
+      const peer = this.connections[id]
+
+      if (!peer || !peer?.connected) {
+        this.dht.removeProvider(id, hash)
+        return this.requestData(hash, store?.name || store)
+      }
 
-    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)
+      const node = await this.prepareMessage(data)
 
-    if (peer?.connected) {
-      try {
-        if (peer) data = await peer.request(node.encoded)
-        else {
-          // fallback and try every provider found
-          const promises = []
-          const providers = await this.providersFor(hash, store)
-          for (const provider of Object.values(providers)) {
-            const peer = this.connections[provider.id]
-
-            if (peer) promises.push(peer.request(node.encoded))
+      if (peer?.connected) {
+        try {
+          if (peer) data = await peer.request(node.encoded)
+          else {
+            // fallback and try every provider found
+            const promises = []
+            const providers = await this.providersFor(hash, store)
+            for (const provider of Object.values(providers)) {
+              const peer = this.connections[provider.id]
+
+              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.length === 0) throw nothingFoundError(hash)
-        const proto = await protoFor(data)
-        // TODO: store data automaticly or not
-        return BufferToUint8Array(proto.decoded.data)
-      } catch (error) {
-        debug(`Error while requesting data from ${id}`, error)
-        // if error, remove provider
-        if (this.#peerAttempts[id] > 1) {
-          this.#peerAttempts[id] = 0
-          debug(`Removed provider ${id} for ${hash} after 3 attempts`)
-
-          this.dht.removeProvider(id, hash)
-          console.error(nothingFoundError(hash))
-          return undefined
+          if (data) data = new Uint8Array(Object.values(data))
+          if (!data || data.length === 0) throw nothingFoundError(hash)
+          const proto = await protoFor(data)
+          // TODO: store data automaticly or not
+          return BufferToUint8Array(proto.decoded.data)
+        } catch (error) {
+          debug(`Error while requesting data from ${id}`, error)
+          // if error, remove provider
+          if (this.#peerAttempts[id] > 1) {
+            this.#peerAttempts[id] = 0
+            debug(`Removed provider ${id} for ${hash} after 3 attempts`)
+
+            this.dht.removeProvider(id, hash)
+            console.error(nothingFoundError(hash))
+            return undefined
+          }
+
+          if (this.#peerAttempts[id] === undefined) this.#peerAttempts[id] = 0
+          this.#peerAttempts[id]++
+          return this.requestData(hash, store?.name || store)
         }
 
-        if (this.#peerAttempts[id] === undefined) this.#peerAttempts[id] = 0
-        this.#peerAttempts[id]++
-        return this.requestData(hash, store?.name || store)
+        // this.put(hash, proto.decoded.data)
+      } else {
+        this.dht.removeProvider(id, hash)
       }
-
-      // this.put(hash, proto.decoded.data)
-    } else {
-      this.dht.removeProvider(id, hash)
+      return undefined
+    } catch (error) {
+      console.error(`Error while requesting data for ${hash} from the network`, error)
+      return undefined
     }
-    return
   }
 
   get message() {
@@ -723,7 +730,7 @@ export default class Peernet {
         debug(`get share ${hash}`)
         const data = await shareStore.has(hash)
         if (data) return await shareStore.get(hash)
-        return undefined
+        return this.requestData(hash, 'share')
       },
       /**
        * put share content