@gethashd/bytecave-browser 1.0.48 → 1.0.49

package/dist/{chunk-FSNCYF3O.js → chunk-CVBYHRQD.js}

@@ -6337,6 +6337,7 @@ var ByteCaveClient = class {
     this.knownPeers = /* @__PURE__ */ new Map();
     this.connectionState = "disconnected";
     this.eventListeners = /* @__PURE__ */ new Map();
+    this.PEERS_CACHE_KEY = "bytecave_known_peers";
     this.config = {
       maxPeers: 10,
       connectionTimeout: 3e4,
@@ -6349,6 +6350,7 @@ var ByteCaveClient = class {
     if (config.vaultNodeRegistryAddress && config.rpcUrl) {
       this.contractDiscovery = new ContractDiscovery(config.vaultNodeRegistryAddress, config.rpcUrl);
     }
+    this.loadCachedPeers();
   }
   /**
    * Initialize and start the P2P client
@@ -6518,14 +6520,19 @@ var ByteCaveClient = class {
                 }
                 const health = await p2pProtocolClient.getHealthFromPeer(peer.peerId);
                 if (health) {
-                  this.knownPeers.set(peer.peerId, {
+                  const peerInfo = {
                     peerId: peer.peerId,
                     publicKey: health.publicKey || "",
                     contentTypes: health.contentTypes || "all",
+                    httpEndpoint: health.httpEndpoint || "",
+                    multiaddrs: peer.multiaddrs || [],
+                    relayAddrs: peer.relayAddrs || [],
                     connected: true,
-                    nodeId: health.nodeId
-                  });
-                  console.log("[ByteCave] \u2713 Discovered peer:", health.nodeId || peer.peerId.slice(0, 12));
+                    isRegistered: peer.isRegistered || false,
+                    onChainNodeId: peer.onChainNodeId || ""
+                  };
+                  this.knownPeers.set(peer.peerId, peerInfo);
+                  this.saveCachedPeers();
                 }
               } catch (err) {
                 console.warn("[ByteCave] Failed to process peer from directory:", peer.peerId.slice(0, 12), err.message);
@@ -6614,14 +6621,19 @@ var ByteCaveClient = class {
                 try {
                   const health = await p2pProtocolClient.getHealthFromPeer(peer.peerId);
                   if (health) {
-                    this.knownPeers.set(peer.peerId, {
+                    const peerInfo = {
                       peerId: peer.peerId,
                       publicKey: health.publicKey || "",
                       contentTypes: health.contentTypes || "all",
+                      httpEndpoint: health.httpEndpoint || "",
+                      multiaddrs: peer.multiaddrs || [],
+                      relayAddrs: peer.relayAddrs || [],
                       connected: true,
-                      nodeId: health.nodeId
-                    });
-                    console.log("[ByteCave] Refresh: \u2713 Updated peer info:", health.nodeId || peer.peerId.slice(0, 12));
+                      isRegistered: peer.isRegistered || false,
+                      onChainNodeId: peer.onChainNodeId || ""
+                    };
+                    this.knownPeers.set(peer.peerId, peerInfo);
+                    this.saveCachedPeers();
                   }
                 } catch (err) {
                   console.warn("[ByteCave] Refresh: Failed to get health from peer:", peer.peerId.slice(0, 12), err.message);
@@ -6724,11 +6736,16 @@ Nonce: ${nonce}`;
     }
     console.log("[ByteCave] Attempting storage via WebTransport direct");
     try {
-      let nodes = [];
-      if (this.relayDiscovery) {
-        nodes = await this.relayDiscovery.getConnectedPeers();
-      } else if (this.contractDiscovery) {
-        nodes = await this.contractDiscovery.getActiveNodes();
+      let nodes = Array.from(this.knownPeers.values());
+      if (nodes.length === 0) {
+        console.log("[ByteCave] No cached peers, trying discovery services");
+        if (this.relayDiscovery) {
+          nodes = await this.relayDiscovery.getConnectedPeers();
+        } else if (this.contractDiscovery) {
+          nodes = await this.contractDiscovery.getActiveNodes();
+        }
+      } else {
+        console.log("[ByteCave] Using", nodes.length, "cached peers for WebTransport");
       }
       if (nodes.length === 0) {
         return {
@@ -7046,8 +7063,38 @@ Nonce: ${nonce}`;
       onChainNodeId: announcement.onChainNodeId
     };
     this.knownPeers.set(announcement.peerId, peerInfo);
+    this.saveCachedPeers();
     this.emit("peerAnnounce", peerInfo);
   }
+  /**
+   * Load cached peers from localStorage
+   */
+  loadCachedPeers() {
+    try {
+      const cached = localStorage.getItem(this.PEERS_CACHE_KEY);
+      if (cached) {
+        const peers = JSON.parse(cached);
+        console.log("[ByteCave] Loaded", peers.length, "cached peers from localStorage");
+        for (const peer of peers) {
+          this.knownPeers.set(peer.peerId, { ...peer, connected: false });
+        }
+      }
+    } catch (error) {
+      console.warn("[ByteCave] Failed to load cached peers:", error);
+    }
+  }
+  /**
+   * Save known peers to localStorage
+   */
+  saveCachedPeers() {
+    try {
+      const peers = Array.from(this.knownPeers.values());
+      localStorage.setItem(this.PEERS_CACHE_KEY, JSON.stringify(peers));
+      console.log("[ByteCave] Saved", peers.length, "peers to localStorage");
+    } catch (error) {
+      console.warn("[ByteCave] Failed to save cached peers:", error);
+    }
+  }
   /**
    * Check if a nodeId is registered in the on-chain registry
    */

package/dist/client.d.ts

@@ -14,6 +14,7 @@ export declare class ByteCaveClient {
     private knownPeers;
     private connectionState;
     private eventListeners;
+    private readonly PEERS_CACHE_KEY;
     constructor(config: ByteCaveConfig);
     /**
      * Initialize and start the P2P client
@@ -97,6 +98,14 @@ export declare class ByteCaveClient {
     private setupEventListeners;
     private setupPubsub;
     private handlePeerAnnouncement;
+    /**
+     * Load cached peers from localStorage
+     */
+    private loadCachedPeers;
+    /**
+     * Save known peers to localStorage
+     */
+    private saveCachedPeers;
     /**
      * Check if a nodeId is registered in the on-chain registry
      */

package/dist/index.cjs

@@ -6390,6 +6390,7 @@ var ByteCaveClient = class {
     this.knownPeers = /* @__PURE__ */ new Map();
     this.connectionState = "disconnected";
     this.eventListeners = /* @__PURE__ */ new Map();
+    this.PEERS_CACHE_KEY = "bytecave_known_peers";
     this.config = {
       maxPeers: 10,
       connectionTimeout: 3e4,
@@ -6402,6 +6403,7 @@ var ByteCaveClient = class {
     if (config.vaultNodeRegistryAddress && config.rpcUrl) {
       this.contractDiscovery = new ContractDiscovery(config.vaultNodeRegistryAddress, config.rpcUrl);
     }
+    this.loadCachedPeers();
   }
   /**
    * Initialize and start the P2P client
@@ -6571,14 +6573,19 @@ var ByteCaveClient = class {
                 }
                 const health = await p2pProtocolClient.getHealthFromPeer(peer.peerId);
                 if (health) {
-                  this.knownPeers.set(peer.peerId, {
+                  const peerInfo = {
                     peerId: peer.peerId,
                     publicKey: health.publicKey || "",
                     contentTypes: health.contentTypes || "all",
+                    httpEndpoint: health.httpEndpoint || "",
+                    multiaddrs: peer.multiaddrs || [],
+                    relayAddrs: peer.relayAddrs || [],
                     connected: true,
-                    nodeId: health.nodeId
-                  });
-                  console.log("[ByteCave] \u2713 Discovered peer:", health.nodeId || peer.peerId.slice(0, 12));
+                    isRegistered: peer.isRegistered || false,
+                    onChainNodeId: peer.onChainNodeId || ""
+                  };
+                  this.knownPeers.set(peer.peerId, peerInfo);
+                  this.saveCachedPeers();
                 }
               } catch (err) {
                 console.warn("[ByteCave] Failed to process peer from directory:", peer.peerId.slice(0, 12), err.message);
@@ -6667,14 +6674,19 @@ var ByteCaveClient = class {
                 try {
                   const health = await p2pProtocolClient.getHealthFromPeer(peer.peerId);
                   if (health) {
-                    this.knownPeers.set(peer.peerId, {
+                    const peerInfo = {
                       peerId: peer.peerId,
                       publicKey: health.publicKey || "",
                       contentTypes: health.contentTypes || "all",
+                      httpEndpoint: health.httpEndpoint || "",
+                      multiaddrs: peer.multiaddrs || [],
+                      relayAddrs: peer.relayAddrs || [],
                       connected: true,
-                      nodeId: health.nodeId
-                    });
-                    console.log("[ByteCave] Refresh: \u2713 Updated peer info:", health.nodeId || peer.peerId.slice(0, 12));
+                      isRegistered: peer.isRegistered || false,
+                      onChainNodeId: peer.onChainNodeId || ""
+                    };
+                    this.knownPeers.set(peer.peerId, peerInfo);
+                    this.saveCachedPeers();
                   }
                 } catch (err) {
                   console.warn("[ByteCave] Refresh: Failed to get health from peer:", peer.peerId.slice(0, 12), err.message);
@@ -6777,11 +6789,16 @@ Nonce: ${nonce}`;
     }
     console.log("[ByteCave] Attempting storage via WebTransport direct");
     try {
-      let nodes = [];
-      if (this.relayDiscovery) {
-        nodes = await this.relayDiscovery.getConnectedPeers();
-      } else if (this.contractDiscovery) {
-        nodes = await this.contractDiscovery.getActiveNodes();
+      let nodes = Array.from(this.knownPeers.values());
+      if (nodes.length === 0) {
+        console.log("[ByteCave] No cached peers, trying discovery services");
+        if (this.relayDiscovery) {
+          nodes = await this.relayDiscovery.getConnectedPeers();
+        } else if (this.contractDiscovery) {
+          nodes = await this.contractDiscovery.getActiveNodes();
+        }
+      } else {
+        console.log("[ByteCave] Using", nodes.length, "cached peers for WebTransport");
       }
       if (nodes.length === 0) {
         return {
@@ -7099,8 +7116,38 @@ Nonce: ${nonce}`;
       onChainNodeId: announcement.onChainNodeId
     };
     this.knownPeers.set(announcement.peerId, peerInfo);
+    this.saveCachedPeers();
     this.emit("peerAnnounce", peerInfo);
   }
+  /**
+   * Load cached peers from localStorage
+   */
+  loadCachedPeers() {
+    try {
+      const cached = localStorage.getItem(this.PEERS_CACHE_KEY);
+      if (cached) {
+        const peers = JSON.parse(cached);
+        console.log("[ByteCave] Loaded", peers.length, "cached peers from localStorage");
+        for (const peer of peers) {
+          this.knownPeers.set(peer.peerId, { ...peer, connected: false });
+        }
+      }
+    } catch (error) {
+      console.warn("[ByteCave] Failed to load cached peers:", error);
+    }
+  }
+  /**
+   * Save known peers to localStorage
+   */
+  saveCachedPeers() {
+    try {
+      const peers = Array.from(this.knownPeers.values());
+      localStorage.setItem(this.PEERS_CACHE_KEY, JSON.stringify(peers));
+      console.log("[ByteCave] Saved", peers.length, "peers to localStorage");
+    } catch (error) {
+      console.warn("[ByteCave] Failed to save cached peers:", error);
+    }
+  }
   /**
    * Check if a nodeId is registered in the on-chain registry
    */

package/dist/index.js

@@ -13,7 +13,7 @@ import {
   useHashdImage,
   useHashdMedia,
   useHashdUrl
-} from "./chunk-FSNCYF3O.js";
+} from "./chunk-CVBYHRQD.js";
 import {
   clearHashdCache,
   createHashdUrl,

package/dist/react/index.js

@@ -8,7 +8,7 @@ import {
   useHashdImage,
   useHashdMedia,
   useHashdUrl
-} from "../chunk-FSNCYF3O.js";
+} from "../chunk-CVBYHRQD.js";
 import "../chunk-EEZWRIUI.js";
 export {
   HashdAudio,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gethashd/bytecave-browser",
-  "version": "1.0.48",
+  "version": "1.0.49",
   "description": "ByteCave browser client for WebRTC P2P connections to storage nodes",
   "main": "dist/index.cjs",
   "module": "dist/index.js",

package/src/client.ts

@@ -44,6 +44,7 @@ export class ByteCaveClient {
   private knownPeers: Map<string, PeerInfo> = new Map();
   private connectionState: ConnectionState = 'disconnected';
   private eventListeners: Map<string, Set<Function>> = new Map();
+  private readonly PEERS_CACHE_KEY = 'bytecave_known_peers';
 
   constructor(config: ByteCaveConfig) {
     this.config = {
@@ -62,6 +63,9 @@ export class ByteCaveClient {
     if (config.vaultNodeRegistryAddress && config.rpcUrl) {
       this.contractDiscovery = new ContractDiscovery(config.vaultNodeRegistryAddress, config.rpcUrl);
     }
+    
+    // Load cached peers from localStorage
+    this.loadCachedPeers();
   }
 
   /**
@@ -277,14 +281,19 @@ export class ByteCaveClient {
                 // Fetch health data
                 const health = await p2pProtocolClient.getHealthFromPeer(peer.peerId);
                 if (health) {
-                  this.knownPeers.set(peer.peerId, {
+                  const peerInfo = {
                     peerId: peer.peerId,
                     publicKey: health.publicKey || '',
                     contentTypes: health.contentTypes || 'all',
+                    httpEndpoint: (health as any).httpEndpoint || '',
+                    multiaddrs: peer.multiaddrs || [],
+                    relayAddrs: (peer as any).relayAddrs || [],
                     connected: true,
-                    nodeId: health.nodeId
-                  });
-                  console.log('[ByteCave] ✓ Discovered peer:', health.nodeId || peer.peerId.slice(0, 12));
+                    isRegistered: (peer as any).isRegistered || false,
+                    onChainNodeId: (peer as any).onChainNodeId || ''
+                  };
+                  this.knownPeers.set(peer.peerId, peerInfo);
+                  this.saveCachedPeers();
                 }
               } catch (err: any) {
                 console.warn('[ByteCave] Failed to process peer from directory:', peer.peerId.slice(0, 12), err.message);
@@ -391,14 +400,19 @@ export class ByteCaveClient {
                 try {
                   const health = await p2pProtocolClient.getHealthFromPeer(peer.peerId);
                   if (health) {
-                    this.knownPeers.set(peer.peerId, {
+                    const peerInfo = {
                       peerId: peer.peerId,
                       publicKey: health.publicKey || '',
                       contentTypes: health.contentTypes || 'all',
+                      httpEndpoint: (health as any).httpEndpoint || '',
+                      multiaddrs: (peer as any).multiaddrs || [],
+                      relayAddrs: (peer as any).relayAddrs || [],
                       connected: true,
-                      nodeId: health.nodeId
-                    });
-                    console.log('[ByteCave] Refresh: ✓ Updated peer info:', health.nodeId || peer.peerId.slice(0, 12));
+                      isRegistered: (peer as any).isRegistered || false,
+                      onChainNodeId: (peer as any).onChainNodeId || ''
+                    };
+                    this.knownPeers.set(peer.peerId, peerInfo);
+                    this.saveCachedPeers();
                   }
                 } catch (err: any) {
                   console.warn('[ByteCave] Refresh: Failed to get health from peer:', peer.peerId.slice(0, 12), err.message);
@@ -528,13 +542,18 @@ Nonce: ${nonce}`;
     console.log('[ByteCave] Attempting storage via WebTransport direct');
     
     try {
-      // Get nodes from relay discovery or contract discovery
-      let nodes: any[] = [];
+      // Try cached peers first, then discovery services
+      let nodes: any[] = Array.from(this.knownPeers.values());
       
-      if (this.relayDiscovery) {
-        nodes = await this.relayDiscovery.getConnectedPeers();
-      } else if (this.contractDiscovery) {
-        nodes = await this.contractDiscovery.getActiveNodes();
+      if (nodes.length === 0) {
+        console.log('[ByteCave] No cached peers, trying discovery services');
+        if (this.relayDiscovery) {
+          nodes = await this.relayDiscovery.getConnectedPeers();
+        } else if (this.contractDiscovery) {
+          nodes = await this.contractDiscovery.getActiveNodes();
+        }
+      } else {
+        console.log('[ByteCave] Using', nodes.length, 'cached peers for WebTransport');
       }
 
       if (nodes.length === 0) {
@@ -934,11 +953,43 @@ Nonce: ${nonce}`;
     };
 
     this.knownPeers.set(announcement.peerId, peerInfo);
+    this.saveCachedPeers();
 
     this.emit('peerAnnounce', peerInfo);
   }
   
 
+  /**
+   * Load cached peers from localStorage
+   */
+  private loadCachedPeers(): void {
+    try {
+      const cached = localStorage.getItem(this.PEERS_CACHE_KEY);
+      if (cached) {
+        const peers = JSON.parse(cached);
+        console.log('[ByteCave] Loaded', peers.length, 'cached peers from localStorage');
+        for (const peer of peers) {
+          this.knownPeers.set(peer.peerId, { ...peer, connected: false });
+        }
+      }
+    } catch (error) {
+      console.warn('[ByteCave] Failed to load cached peers:', error);
+    }
+  }
+
+  /**
+   * Save known peers to localStorage
+   */
+  private saveCachedPeers(): void {
+    try {
+      const peers = Array.from(this.knownPeers.values());
+      localStorage.setItem(this.PEERS_CACHE_KEY, JSON.stringify(peers));
+      console.log('[ByteCave] Saved', peers.length, 'peers to localStorage');
+    } catch (error) {
+      console.warn('[ByteCave] Failed to save cached peers:', error);
+    }
+  }
+
   /**
    * Check if a nodeId is registered in the on-chain registry
    */