@gethashd/bytecave-browser 1.0.47 → 1.0.49

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

@@ -6226,6 +6226,101 @@ var StorageWebSocketClient = class {
   }
 };
 
+// src/storage-webtransport.ts
+var StorageWebTransportClient = class {
+  constructor(nodeMultiaddr) {
+    this.nodeMultiaddr = nodeMultiaddr;
+  }
+  /**
+   * Store data via WebTransport direct to node
+   */
+  async store(request) {
+    try {
+      if (typeof WebTransport === "undefined") {
+        return {
+          success: false,
+          error: "WebTransport not supported in this browser"
+        };
+      }
+      const url = this.multiaddrToWebTransportUrl(this.nodeMultiaddr);
+      if (!url) {
+        return {
+          success: false,
+          error: "Invalid WebTransport multiaddr"
+        };
+      }
+      console.log("[WebTransport] Connecting to node:", url);
+      const transport = new WebTransport(url);
+      await transport.ready;
+      console.log("[WebTransport] Connected, opening bidirectional stream");
+      const stream = await transport.createBidirectionalStream();
+      const writer = stream.writable.getWriter();
+      const reader = stream.readable.getReader();
+      const requestData = {
+        type: "storage-request",
+        data: Array.from(request.data),
+        // Convert Uint8Array to array for JSON
+        contentType: request.contentType,
+        hashIdToken: request.hashIdToken,
+        authorization: request.authorization
+      };
+      const requestJson = JSON.stringify(requestData);
+      const requestBytes = new TextEncoder().encode(requestJson);
+      await writer.write(requestBytes);
+      await writer.close();
+      console.log("[WebTransport] Request sent, waiting for response");
+      const { value, done } = await reader.read();
+      if (done || !value) {
+        return {
+          success: false,
+          error: "No response from node"
+        };
+      }
+      const responseJson = new TextDecoder().decode(value);
+      const response = JSON.parse(responseJson);
+      console.log("[WebTransport] Response received:", response);
+      await transport.close();
+      return response;
+    } catch (error) {
+      console.error("[WebTransport] Storage failed:", error);
+      return {
+        success: false,
+        error: error.message || "WebTransport storage failed"
+      };
+    }
+  }
+  /**
+   * Convert libp2p multiaddr to WebTransport URL
+   */
+  multiaddrToWebTransportUrl(multiaddr2) {
+    try {
+      const parts = multiaddr2.split("/").filter((p) => p);
+      let ip = "";
+      let port = "";
+      let hasQuic = false;
+      let hasWebTransport = false;
+      for (let i = 0; i < parts.length; i++) {
+        if (parts[i] === "ip4" && i + 1 < parts.length) {
+          ip = parts[i + 1];
+        } else if (parts[i] === "udp" && i + 1 < parts.length) {
+          port = parts[i + 1];
+        } else if (parts[i] === "quic-v1") {
+          hasQuic = true;
+        } else if (parts[i] === "webtransport") {
+          hasWebTransport = true;
+        }
+      }
+      if (!ip || !port || !hasQuic || !hasWebTransport) {
+        return null;
+      }
+      return `https://${ip}:${port}`;
+    } catch (error) {
+      console.error("[WebTransport] Failed to parse multiaddr:", error);
+      return null;
+    }
+  }
+};
+
 // src/contracts/ContentRegistry.ts
 var CONTENT_REGISTRY_ABI = [
   "function registerContent(bytes32 cid, address owner, bytes32 appId, uint256 hashIdToken) external",
@@ -6242,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,
@@ -6254,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
@@ -6423,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);
@@ -6519,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);
@@ -6591,15 +6698,81 @@ Nonce: ${nonce}`;
         console.warn("[ByteCave] Failed to create authorization:", err.message);
       }
     }
-    if (!this.config.relayWsUrl) {
-      return { success: false, error: "WebSocket relay URL not configured" };
+    if (this.config.relayWsUrl) {
+      console.log("[ByteCave] Attempting storage via WebSocket relay");
+      try {
+        if (!this.storageWsClient) {
+          this.storageWsClient = new StorageWebSocketClient(this.config.relayWsUrl);
+        }
+        const wsAuth = authorization ? {
+          signature: authorization.signature,
+          address: authorization.sender,
+          timestamp: authorization.timestamp,
+          nonce: authorization.nonce,
+          appId: authorization.appId,
+          contentHash: authorization.contentHash
+        } : void 0;
+        const result = await this.storageWsClient.store({
+          data: dataArray,
+          contentType: mimeType || "application/octet-stream",
+          hashIdToken,
+          authorization: wsAuth,
+          timeout: 3e4
+        });
+        if (result.success && result.cid) {
+          console.log("[ByteCave] \u2713 WebSocket storage successful:", result.cid);
+          return {
+            success: true,
+            cid: result.cid,
+            peerId: "relay-ws"
+          };
+        }
+        console.warn("[ByteCave] WebSocket storage failed, trying WebTransport:", result.error);
+      } catch (err) {
+        console.warn("[ByteCave] WebSocket storage exception, trying WebTransport:", err.message);
+      }
+    } else {
+      console.log("[ByteCave] WebSocket relay not configured, trying WebTransport");
     }
-    console.log("[ByteCave] Storing via WebSocket relay");
+    console.log("[ByteCave] Attempting storage via WebTransport direct");
     try {
-      if (!this.storageWsClient) {
-        this.storageWsClient = new StorageWebSocketClient(this.config.relayWsUrl);
+      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");
       }
-      const wsAuth = authorization ? {
+      if (nodes.length === 0) {
+        return {
+          success: false,
+          error: "No nodes available for WebTransport storage"
+        };
+      }
+      const nodeWithWebTransport = nodes.find(
+        (node) => node.multiaddrs?.some((addr) => addr.includes("/webtransport"))
+      );
+      if (!nodeWithWebTransport || !nodeWithWebTransport.multiaddrs) {
+        return {
+          success: false,
+          error: "No nodes with WebTransport support found"
+        };
+      }
+      const wtMultiaddr = nodeWithWebTransport.multiaddrs.find(
+        (addr) => addr.includes("/webtransport")
+      );
+      if (!wtMultiaddr) {
+        return {
+          success: false,
+          error: "No WebTransport multiaddr found"
+        };
+      }
+      const wtClient = new StorageWebTransportClient(wtMultiaddr);
+      const wtAuth = authorization ? {
         signature: authorization.signature,
         address: authorization.sender,
         timestamp: authorization.timestamp,
@@ -6607,26 +6780,25 @@ Nonce: ${nonce}`;
         appId: authorization.appId,
         contentHash: authorization.contentHash
       } : void 0;
-      const result = await this.storageWsClient.store({
+      const result = await wtClient.store({
         data: dataArray,
         contentType: mimeType || "application/octet-stream",
         hashIdToken,
-        authorization: wsAuth,
-        timeout: 3e4
+        authorization: wtAuth
       });
       if (result.success && result.cid) {
-        console.log("[ByteCave] \u2713 WebSocket storage successful:", result.cid);
+        console.log("[ByteCave] \u2713 WebTransport storage successful:", result.cid);
         return {
           success: true,
           cid: result.cid,
-          peerId: "relay-ws"
+          peerId: nodeWithWebTransport.peerId
         };
       }
-      console.warn("[ByteCave] WebSocket storage failed:", result.error);
-      return { success: false, error: result.error || "WebSocket storage failed" };
+      console.error("[ByteCave] WebTransport storage failed:", result.error);
+      return { success: false, error: result.error || "All storage methods failed" };
     } catch (err) {
-      console.error("[ByteCave] WebSocket storage exception:", err.message);
-      return { success: false, error: err.message };
+      console.error("[ByteCave] WebTransport storage exception:", err.message);
+      return { success: false, error: `All storage methods failed: ${err.message}` };
     }
   }
   /**
@@ -6891,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

@@ -6279,6 +6279,101 @@ var StorageWebSocketClient = class {
   }
 };
 
+// src/storage-webtransport.ts
+var StorageWebTransportClient = class {
+  constructor(nodeMultiaddr) {
+    this.nodeMultiaddr = nodeMultiaddr;
+  }
+  /**
+   * Store data via WebTransport direct to node
+   */
+  async store(request) {
+    try {
+      if (typeof WebTransport === "undefined") {
+        return {
+          success: false,
+          error: "WebTransport not supported in this browser"
+        };
+      }
+      const url = this.multiaddrToWebTransportUrl(this.nodeMultiaddr);
+      if (!url) {
+        return {
+          success: false,
+          error: "Invalid WebTransport multiaddr"
+        };
+      }
+      console.log("[WebTransport] Connecting to node:", url);
+      const transport = new WebTransport(url);
+      await transport.ready;
+      console.log("[WebTransport] Connected, opening bidirectional stream");
+      const stream = await transport.createBidirectionalStream();
+      const writer = stream.writable.getWriter();
+      const reader = stream.readable.getReader();
+      const requestData = {
+        type: "storage-request",
+        data: Array.from(request.data),
+        // Convert Uint8Array to array for JSON
+        contentType: request.contentType,
+        hashIdToken: request.hashIdToken,
+        authorization: request.authorization
+      };
+      const requestJson = JSON.stringify(requestData);
+      const requestBytes = new TextEncoder().encode(requestJson);
+      await writer.write(requestBytes);
+      await writer.close();
+      console.log("[WebTransport] Request sent, waiting for response");
+      const { value, done } = await reader.read();
+      if (done || !value) {
+        return {
+          success: false,
+          error: "No response from node"
+        };
+      }
+      const responseJson = new TextDecoder().decode(value);
+      const response = JSON.parse(responseJson);
+      console.log("[WebTransport] Response received:", response);
+      await transport.close();
+      return response;
+    } catch (error) {
+      console.error("[WebTransport] Storage failed:", error);
+      return {
+        success: false,
+        error: error.message || "WebTransport storage failed"
+      };
+    }
+  }
+  /**
+   * Convert libp2p multiaddr to WebTransport URL
+   */
+  multiaddrToWebTransportUrl(multiaddr2) {
+    try {
+      const parts = multiaddr2.split("/").filter((p) => p);
+      let ip = "";
+      let port = "";
+      let hasQuic = false;
+      let hasWebTransport = false;
+      for (let i = 0; i < parts.length; i++) {
+        if (parts[i] === "ip4" && i + 1 < parts.length) {
+          ip = parts[i + 1];
+        } else if (parts[i] === "udp" && i + 1 < parts.length) {
+          port = parts[i + 1];
+        } else if (parts[i] === "quic-v1") {
+          hasQuic = true;
+        } else if (parts[i] === "webtransport") {
+          hasWebTransport = true;
+        }
+      }
+      if (!ip || !port || !hasQuic || !hasWebTransport) {
+        return null;
+      }
+      return `https://${ip}:${port}`;
+    } catch (error) {
+      console.error("[WebTransport] Failed to parse multiaddr:", error);
+      return null;
+    }
+  }
+};
+
 // src/contracts/ContentRegistry.ts
 var CONTENT_REGISTRY_ABI = [
   "function registerContent(bytes32 cid, address owner, bytes32 appId, uint256 hashIdToken) external",
@@ -6295,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,
@@ -6307,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
@@ -6476,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);
@@ -6572,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);
@@ -6644,15 +6751,81 @@ Nonce: ${nonce}`;
         console.warn("[ByteCave] Failed to create authorization:", err.message);
       }
     }
-    if (!this.config.relayWsUrl) {
-      return { success: false, error: "WebSocket relay URL not configured" };
+    if (this.config.relayWsUrl) {
+      console.log("[ByteCave] Attempting storage via WebSocket relay");
+      try {
+        if (!this.storageWsClient) {
+          this.storageWsClient = new StorageWebSocketClient(this.config.relayWsUrl);
+        }
+        const wsAuth = authorization ? {
+          signature: authorization.signature,
+          address: authorization.sender,
+          timestamp: authorization.timestamp,
+          nonce: authorization.nonce,
+          appId: authorization.appId,
+          contentHash: authorization.contentHash
+        } : void 0;
+        const result = await this.storageWsClient.store({
+          data: dataArray,
+          contentType: mimeType || "application/octet-stream",
+          hashIdToken,
+          authorization: wsAuth,
+          timeout: 3e4
+        });
+        if (result.success && result.cid) {
+          console.log("[ByteCave] \u2713 WebSocket storage successful:", result.cid);
+          return {
+            success: true,
+            cid: result.cid,
+            peerId: "relay-ws"
+          };
+        }
+        console.warn("[ByteCave] WebSocket storage failed, trying WebTransport:", result.error);
+      } catch (err) {
+        console.warn("[ByteCave] WebSocket storage exception, trying WebTransport:", err.message);
+      }
+    } else {
+      console.log("[ByteCave] WebSocket relay not configured, trying WebTransport");
     }
-    console.log("[ByteCave] Storing via WebSocket relay");
+    console.log("[ByteCave] Attempting storage via WebTransport direct");
     try {
-      if (!this.storageWsClient) {
-        this.storageWsClient = new StorageWebSocketClient(this.config.relayWsUrl);
+      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");
       }
-      const wsAuth = authorization ? {
+      if (nodes.length === 0) {
+        return {
+          success: false,
+          error: "No nodes available for WebTransport storage"
+        };
+      }
+      const nodeWithWebTransport = nodes.find(
+        (node) => node.multiaddrs?.some((addr) => addr.includes("/webtransport"))
+      );
+      if (!nodeWithWebTransport || !nodeWithWebTransport.multiaddrs) {
+        return {
+          success: false,
+          error: "No nodes with WebTransport support found"
+        };
+      }
+      const wtMultiaddr = nodeWithWebTransport.multiaddrs.find(
+        (addr) => addr.includes("/webtransport")
+      );
+      if (!wtMultiaddr) {
+        return {
+          success: false,
+          error: "No WebTransport multiaddr found"
+        };
+      }
+      const wtClient = new StorageWebTransportClient(wtMultiaddr);
+      const wtAuth = authorization ? {
         signature: authorization.signature,
         address: authorization.sender,
         timestamp: authorization.timestamp,
@@ -6660,26 +6833,25 @@ Nonce: ${nonce}`;
         appId: authorization.appId,
         contentHash: authorization.contentHash
       } : void 0;
-      const result = await this.storageWsClient.store({
+      const result = await wtClient.store({
         data: dataArray,
         contentType: mimeType || "application/octet-stream",
         hashIdToken,
-        authorization: wsAuth,
-        timeout: 3e4
+        authorization: wtAuth
       });
       if (result.success && result.cid) {
-        console.log("[ByteCave] \u2713 WebSocket storage successful:", result.cid);
+        console.log("[ByteCave] \u2713 WebTransport storage successful:", result.cid);
         return {
           success: true,
           cid: result.cid,
-          peerId: "relay-ws"
+          peerId: nodeWithWebTransport.peerId
         };
       }
-      console.warn("[ByteCave] WebSocket storage failed:", result.error);
-      return { success: false, error: result.error || "WebSocket storage failed" };
+      console.error("[ByteCave] WebTransport storage failed:", result.error);
+      return { success: false, error: result.error || "All storage methods failed" };
     } catch (err) {
-      console.error("[ByteCave] WebSocket storage exception:", err.message);
-      return { success: false, error: err.message };
+      console.error("[ByteCave] WebTransport storage exception:", err.message);
+      return { success: false, error: `All storage methods failed: ${err.message}` };
     }
   }
   /**
@@ -6944,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-FOQ3CE3H.js";
+} from "./chunk-CVBYHRQD.js";
 import {
   clearHashdCache,
   createHashdUrl,

package/dist/react/index.js

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

package/dist/storage-webtransport.d.ts

@@ -0,0 +1,36 @@
+/**
+ * WebTransport Storage Client
+ *
+ * Provides direct browser-to-node storage over WebTransport (HTTP/3)
+ * Used as fallback when WebSocket relay is unavailable
+ */
+export interface WebTransportStorageRequest {
+    data: Uint8Array;
+    contentType: string;
+    hashIdToken?: number;
+    authorization?: {
+        signature: string;
+        address: string;
+        timestamp: number;
+        nonce: string;
+        appId: string;
+        contentHash: string;
+    };
+}
+export interface WebTransportStorageResponse {
+    success: boolean;
+    cid?: string;
+    error?: string;
+}
+export declare class StorageWebTransportClient {
+    private nodeMultiaddr;
+    constructor(nodeMultiaddr: string);
+    /**
+     * Store data via WebTransport direct to node
+     */
+    store(request: WebTransportStorageRequest): Promise<WebTransportStorageResponse>;
+    /**
+     * Convert libp2p multiaddr to WebTransport URL
+     */
+    private multiaddrToWebTransportUrl;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gethashd/bytecave-browser",
-  "version": "1.0.47",
+  "version": "1.0.49",
   "description": "ByteCave browser client for WebRTC P2P connections to storage nodes",
   "main": "dist/index.cjs",
   "module": "dist/index.js",
@@ -45,6 +45,7 @@
     "@libp2p/identify": "^4.0.9",
     "@libp2p/webrtc": "^6.0.10",
     "@libp2p/websockets": "^10.1.2",
+    "@libp2p/webtransport": "^6.0.12",
     "@multiformats/multiaddr": "^13.0.1",
     "ethers": "^6.0.0",
     "libp2p": "^3.1.2",

package/src/client.ts

@@ -21,6 +21,7 @@ import { ethers } from 'ethers';
 import { ContractDiscovery, RelayDiscovery } from './discovery.js';
 import { p2pProtocolClient } from './p2p-protocols.js';
 import { StorageWebSocketClient } from './storage-websocket.js';
+import { StorageWebTransportClient } from './storage-webtransport.js';
 import { CONTENT_REGISTRY_ABI } from './contracts/ContentRegistry.js';
 import type { 
   ByteCaveConfig, 
@@ -43,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 = {
@@ -61,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();
   }
 
   /**
@@ -276,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);
@@ -390,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);
@@ -476,19 +491,103 @@ Nonce: ${nonce}`;
       }
     }
 
-    // Use WebSocket relay for storage (simpler connection management than direct P2P)
-    if (!this.config.relayWsUrl) {
-      return { success: false, error: 'WebSocket relay URL not configured' };
+    // Storage fallback strategy:
+    // 1. Try WebSocket relay (most reliable)
+    // 2. If relay fails, try WebTransport direct to node
+    
+    // Try WebSocket relay first
+    if (this.config.relayWsUrl) {
+      console.log('[ByteCave] Attempting storage via WebSocket relay');
+      
+      try {
+        if (!this.storageWsClient) {
+          this.storageWsClient = new StorageWebSocketClient(this.config.relayWsUrl);
+        }
+
+        const wsAuth = authorization ? {
+          signature: authorization.signature,
+          address: authorization.sender,
+          timestamp: authorization.timestamp,
+          nonce: authorization.nonce,
+          appId: authorization.appId,
+          contentHash: authorization.contentHash
+        } : undefined;
+
+        const result = await this.storageWsClient.store({
+          data: dataArray,
+          contentType: mimeType || 'application/octet-stream',
+          hashIdToken,
+          authorization: wsAuth,
+          timeout: 30000
+        });
+
+        if (result.success && result.cid) {
+          console.log('[ByteCave] ✓ WebSocket storage successful:', result.cid);
+          return {
+            success: true,
+            cid: result.cid,
+            peerId: 'relay-ws'
+          };
+        }
+
+        console.warn('[ByteCave] WebSocket storage failed, trying WebTransport:', result.error);
+      } catch (err: any) {
+        console.warn('[ByteCave] WebSocket storage exception, trying WebTransport:', err.message);
+      }
+    } else {
+      console.log('[ByteCave] WebSocket relay not configured, trying WebTransport');
     }
 
-    console.log('[ByteCave] Storing via WebSocket relay');
+    // Fallback to WebTransport direct to node
+    console.log('[ByteCave] Attempting storage via WebTransport direct');
     
     try {
-      if (!this.storageWsClient) {
-        this.storageWsClient = new StorageWebSocketClient(this.config.relayWsUrl);
+      // Try cached peers first, then discovery services
+      let nodes: any[] = 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 { 
+          success: false, 
+          error: 'No nodes available for WebTransport storage' 
+        };
+      }
+
+      const nodeWithWebTransport = nodes.find((node: any) => 
+        node.multiaddrs?.some((addr: string) => addr.includes('/webtransport'))
+      );
+
+      if (!nodeWithWebTransport || !nodeWithWebTransport.multiaddrs) {
+        return { 
+          success: false, 
+          error: 'No nodes with WebTransport support found' 
+        };
       }
 
-      const wsAuth = authorization ? {
+      const wtMultiaddr = nodeWithWebTransport.multiaddrs.find((addr: string) => 
+        addr.includes('/webtransport')
+      );
+
+      if (!wtMultiaddr) {
+        return { 
+          success: false, 
+          error: 'No WebTransport multiaddr found' 
+        };
+      }
+
+      const wtClient = new StorageWebTransportClient(wtMultiaddr);
+      
+      const wtAuth = authorization ? {
         signature: authorization.signature,
         address: authorization.sender,
         timestamp: authorization.timestamp,
@@ -497,28 +596,27 @@ Nonce: ${nonce}`;
         contentHash: authorization.contentHash
       } : undefined;
 
-      const result = await this.storageWsClient.store({
+      const result = await wtClient.store({
         data: dataArray,
         contentType: mimeType || 'application/octet-stream',
         hashIdToken,
-        authorization: wsAuth,
-        timeout: 30000
+        authorization: wtAuth
       });
 
       if (result.success && result.cid) {
-        console.log('[ByteCave] ✓ WebSocket storage successful:', result.cid);
+        console.log('[ByteCave] ✓ WebTransport storage successful:', result.cid);
         return {
           success: true,
           cid: result.cid,
-          peerId: 'relay-ws'
+          peerId: nodeWithWebTransport.peerId
         };
       }
 
-      console.warn('[ByteCave] WebSocket storage failed:', result.error);
-      return { success: false, error: result.error || 'WebSocket storage failed' };
+      console.error('[ByteCave] WebTransport storage failed:', result.error);
+      return { success: false, error: result.error || 'All storage methods failed' };
     } catch (err: any) {
-      console.error('[ByteCave] WebSocket storage exception:', err.message);
-      return { success: false, error: err.message };
+      console.error('[ByteCave] WebTransport storage exception:', err.message);
+      return { success: false, error: `All storage methods failed: ${err.message}` };
     }
   }
 
@@ -855,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
    */

package/src/storage-webtransport.ts

@@ -0,0 +1,156 @@
+/**
+ * WebTransport Storage Client
+ * 
+ * Provides direct browser-to-node storage over WebTransport (HTTP/3)
+ * Used as fallback when WebSocket relay is unavailable
+ */
+
+// Logger removed - using console.log for browser compatibility
+
+export interface WebTransportStorageRequest {
+  data: Uint8Array;
+  contentType: string;
+  hashIdToken?: number;
+  authorization?: {
+    signature: string;
+    address: string;
+    timestamp: number;
+    nonce: string;
+    appId: string;
+    contentHash: string;
+  };
+}
+
+export interface WebTransportStorageResponse {
+  success: boolean;
+  cid?: string;
+  error?: string;
+}
+
+export class StorageWebTransportClient {
+  private nodeMultiaddr: string;
+
+  constructor(nodeMultiaddr: string) {
+    this.nodeMultiaddr = nodeMultiaddr;
+  }
+
+  /**
+   * Store data via WebTransport direct to node
+   */
+  async store(request: WebTransportStorageRequest): Promise<WebTransportStorageResponse> {
+    try {
+      // Check if WebTransport is supported
+      if (typeof WebTransport === 'undefined') {
+        return {
+          success: false,
+          error: 'WebTransport not supported in this browser'
+        };
+      }
+
+      // Parse multiaddr to get WebTransport URL
+      // Format: /ip4/127.0.0.1/udp/4001/quic-v1/webtransport/certhash/...
+      const url = this.multiaddrToWebTransportUrl(this.nodeMultiaddr);
+      if (!url) {
+        return {
+          success: false,
+          error: 'Invalid WebTransport multiaddr'
+        };
+      }
+
+      console.log('[WebTransport] Connecting to node:', url);
+
+      // Create WebTransport connection
+      const transport = new WebTransport(url);
+      await transport.ready;
+
+      console.log('[WebTransport] Connected, opening bidirectional stream');
+
+      // Open bidirectional stream for storage protocol
+      const stream = await transport.createBidirectionalStream();
+      const writer = stream.writable.getWriter();
+      const reader = stream.readable.getReader();
+
+      // Send storage request
+      const requestData = {
+        type: 'storage-request',
+        data: Array.from(request.data), // Convert Uint8Array to array for JSON
+        contentType: request.contentType,
+        hashIdToken: request.hashIdToken,
+        authorization: request.authorization
+      };
+
+      const requestJson = JSON.stringify(requestData);
+      const requestBytes = new TextEncoder().encode(requestJson);
+      
+      await writer.write(requestBytes);
+      await writer.close();
+
+      console.log('[WebTransport] Request sent, waiting for response');
+
+      // Read response
+      const { value, done } = await reader.read();
+      if (done || !value) {
+        return {
+          success: false,
+          error: 'No response from node'
+        };
+      }
+
+      const responseJson = new TextDecoder().decode(value);
+      const response = JSON.parse(responseJson);
+
+      console.log('[WebTransport] Response received:', response);
+
+      // Close transport
+      await transport.close();
+
+      return response;
+
+    } catch (error: any) {
+      console.error('[WebTransport] Storage failed:', error);
+      return {
+        success: false,
+        error: error.message || 'WebTransport storage failed'
+      };
+    }
+  }
+
+  /**
+   * Convert libp2p multiaddr to WebTransport URL
+   */
+  private multiaddrToWebTransportUrl(multiaddr: string): string | null {
+    try {
+      // Parse multiaddr format: /ip4/127.0.0.1/udp/4001/quic-v1/webtransport
+      const parts = multiaddr.split('/').filter(p => p);
+      
+      let ip = '';
+      let port = '';
+      let hasQuic = false;
+      let hasWebTransport = false;
+
+      for (let i = 0; i < parts.length; i++) {
+        if (parts[i] === 'ip4' && i + 1 < parts.length) {
+          ip = parts[i + 1];
+        } else if (parts[i] === 'udp' && i + 1 < parts.length) {
+          port = parts[i + 1];
+        } else if (parts[i] === 'quic-v1') {
+          hasQuic = true;
+        } else if (parts[i] === 'webtransport') {
+          hasWebTransport = true;
+        }
+      }
+
+      if (!ip || !port || !hasQuic || !hasWebTransport) {
+        return null;
+      }
+
+      // WebTransport URL format: https://ip:port
+      // Note: In production, this needs proper certificate handling
+      return `https://${ip}:${port}`;
+
+    } catch (error) {
+      console.error('[WebTransport] Failed to parse multiaddr:', error);
+      return null;
+    }
+  }
+}