@gethashd/bytecave-browser 1.0.39 → 1.0.40

package/dist/{chunk-SIGWRCA5.js → chunk-IXGM3WHR.js}

@@ -6224,17 +6224,7 @@ var ByteCaveClient = class {
       console.log("[ByteCave] Bootstrap peers:", bootstrapPeers);
       this.node = await createLibp2p({
         transports: [
-          webRTC({
-            rtcConfiguration: {
-              iceServers: [
-                // Google public STUN servers for NAT traversal
-                { urls: "stun:stun.l.google.com:19302" },
-                { urls: "stun:stun1.l.google.com:19302" },
-                // Mozilla public STUN server
-                { urls: "stun:stun.services.mozilla.com" }
-              ]
-            }
-          }),
+          webRTC(),
           webSockets(),
           circuitRelayTransport()
         ],
@@ -6544,77 +6534,43 @@ Nonce: ${nonce}`;
         console.warn("[ByteCave] Failed to create authorization:", err.message);
       }
     }
-    if (this.node) {
-      console.log("[ByteCave] Attempting direct P2P storage (with STUN NAT traversal)");
-      const allPeers = this.node.getPeers();
-      const connectedPeerIds = allPeers.map((p) => p.toString());
-      console.log("[ByteCave] Store - connected storage peers:", connectedPeerIds.length);
-      if (connectedPeerIds.length > 0) {
-        const registeredPeerIds = Array.from(this.knownPeers.values()).filter((p) => p.isRegistered && connectedPeerIds.includes(p.peerId)).map((p) => p.peerId);
-        const storagePeerIds = registeredPeerIds.length > 0 ? [...registeredPeerIds, ...connectedPeerIds.filter((id) => !registeredPeerIds.includes(id))] : connectedPeerIds;
-        for (const peerId of storagePeerIds) {
-          console.log("[ByteCave] Attempting P2P store to peer:", peerId.slice(0, 12) + "...");
-          try {
-            const result = await p2pProtocolClient.storeToPeer(
-              peerId,
-              dataArray,
-              mimeType || "application/octet-stream",
-              authorization,
-              false,
-              // shouldVerifyOnChain - false for browser test storage
-              hashIdToken
-            );
-            if (result.success && result.cid) {
-              console.log("[ByteCave] \u2713 P2P store successful:", result.cid);
-              return {
-                success: true,
-                cid: result.cid,
-                peerId
-              };
-            }
-            console.warn("[ByteCave] \u2717 P2P store failed:", result.error);
-          } catch (err) {
-            console.error("[ByteCave] \u2717 P2P store exception:", err.message);
-          }
-        }
-      }
-      console.log("[ByteCave] P2P storage failed or no peers available, falling back to WebSocket relay");
+    if (!this.config.relayWsUrl) {
+      return { success: false, error: "WebSocket relay URL not configured" };
     }
-    if (this.config.relayWsUrl) {
-      console.log("[ByteCave] Attempting WebSocket storage via relay (fallback)");
-      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 (fallback):", result.cid);
-          return {
-            success: true,
-            cid: result.cid,
-            peerId: "relay-ws"
-          };
-        }
-        console.warn("[ByteCave] WebSocket storage failed:", result.error);
-      } catch (err) {
-        console.warn("[ByteCave] WebSocket storage exception:", err.message);
+    console.log("[ByteCave] Storing 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:", result.error);
+      return { success: false, error: result.error || "WebSocket storage failed" };
+    } catch (err) {
+      console.error("[ByteCave] WebSocket storage exception:", err.message);
+      return { success: false, error: err.message };
     }
-    return { success: false, error: "All storage methods failed (P2P and WebSocket relay)" };
   }
   /**
    * Retrieve ciphertext from a node via P2P only (no HTTP fallback)

package/dist/index.cjs

@@ -6277,17 +6277,7 @@ var ByteCaveClient = class {
       console.log("[ByteCave] Bootstrap peers:", bootstrapPeers);
       this.node = await (0, import_libp2p.createLibp2p)({
         transports: [
-          (0, import_webrtc.webRTC)({
-            rtcConfiguration: {
-              iceServers: [
-                // Google public STUN servers for NAT traversal
-                { urls: "stun:stun.l.google.com:19302" },
-                { urls: "stun:stun1.l.google.com:19302" },
-                // Mozilla public STUN server
-                { urls: "stun:stun.services.mozilla.com" }
-              ]
-            }
-          }),
+          (0, import_webrtc.webRTC)(),
           (0, import_websockets.webSockets)(),
           (0, import_circuit_relay_v2.circuitRelayTransport)()
         ],
@@ -6597,77 +6587,43 @@ Nonce: ${nonce}`;
         console.warn("[ByteCave] Failed to create authorization:", err.message);
       }
     }
-    if (this.node) {
-      console.log("[ByteCave] Attempting direct P2P storage (with STUN NAT traversal)");
-      const allPeers = this.node.getPeers();
-      const connectedPeerIds = allPeers.map((p) => p.toString());
-      console.log("[ByteCave] Store - connected storage peers:", connectedPeerIds.length);
-      if (connectedPeerIds.length > 0) {
-        const registeredPeerIds = Array.from(this.knownPeers.values()).filter((p) => p.isRegistered && connectedPeerIds.includes(p.peerId)).map((p) => p.peerId);
-        const storagePeerIds = registeredPeerIds.length > 0 ? [...registeredPeerIds, ...connectedPeerIds.filter((id) => !registeredPeerIds.includes(id))] : connectedPeerIds;
-        for (const peerId of storagePeerIds) {
-          console.log("[ByteCave] Attempting P2P store to peer:", peerId.slice(0, 12) + "...");
-          try {
-            const result = await p2pProtocolClient.storeToPeer(
-              peerId,
-              dataArray,
-              mimeType || "application/octet-stream",
-              authorization,
-              false,
-              // shouldVerifyOnChain - false for browser test storage
-              hashIdToken
-            );
-            if (result.success && result.cid) {
-              console.log("[ByteCave] \u2713 P2P store successful:", result.cid);
-              return {
-                success: true,
-                cid: result.cid,
-                peerId
-              };
-            }
-            console.warn("[ByteCave] \u2717 P2P store failed:", result.error);
-          } catch (err) {
-            console.error("[ByteCave] \u2717 P2P store exception:", err.message);
-          }
-        }
-      }
-      console.log("[ByteCave] P2P storage failed or no peers available, falling back to WebSocket relay");
+    if (!this.config.relayWsUrl) {
+      return { success: false, error: "WebSocket relay URL not configured" };
     }
-    if (this.config.relayWsUrl) {
-      console.log("[ByteCave] Attempting WebSocket storage via relay (fallback)");
-      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 (fallback):", result.cid);
-          return {
-            success: true,
-            cid: result.cid,
-            peerId: "relay-ws"
-          };
-        }
-        console.warn("[ByteCave] WebSocket storage failed:", result.error);
-      } catch (err) {
-        console.warn("[ByteCave] WebSocket storage exception:", err.message);
+    console.log("[ByteCave] Storing 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:", result.error);
+      return { success: false, error: result.error || "WebSocket storage failed" };
+    } catch (err) {
+      console.error("[ByteCave] WebSocket storage exception:", err.message);
+      return { success: false, error: err.message };
     }
-    return { success: false, error: "All storage methods failed (P2P and WebSocket relay)" };
   }
   /**
    * Retrieve ciphertext from a node via P2P only (no HTTP fallback)

package/dist/index.js

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

package/dist/react/index.js

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

package/package.json

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

package/src/client.ts

@@ -99,17 +99,7 @@ export class ByteCaveClient {
       // Create libp2p node with WebRTC transport
       this.node = await createLibp2p({
         transports: [
-          webRTC({
-            rtcConfiguration: {
-              iceServers: [
-                // Google public STUN servers for NAT traversal
-                { urls: 'stun:stun.l.google.com:19302' },
-                { urls: 'stun:stun1.l.google.com:19302' },
-                // Mozilla public STUN server
-                { urls: 'stun:stun.services.mozilla.com' }
-              ]
-            }
-          }) as any,
+          webRTC() as any,
           webSockets() as any,
           circuitRelayTransport() as any
         ],
@@ -486,99 +476,50 @@ Nonce: ${nonce}`;
       }
     }
 
-    // Try direct P2P storage first (with STUN for NAT traversal)
-    if (this.node) {
-      console.log('[ByteCave] Attempting direct P2P storage (with STUN NAT traversal)');
-      
-      const allPeers = this.node.getPeers();
-      const connectedPeerIds = allPeers.map(p => p.toString());
-      
-      console.log('[ByteCave] Store - connected storage peers:', connectedPeerIds.length);
-      
-      if (connectedPeerIds.length > 0) {
-        // Prioritize registered peers from knownPeers
-        const registeredPeerIds = Array.from(this.knownPeers.values())
-          .filter(p => p.isRegistered && connectedPeerIds.includes(p.peerId))
-          .map(p => p.peerId);
-        
-        const storagePeerIds = registeredPeerIds.length > 0 
-          ? [...registeredPeerIds, ...connectedPeerIds.filter(id => !registeredPeerIds.includes(id))]
-          : connectedPeerIds;
-        
-        for (const peerId of storagePeerIds) {
-          console.log('[ByteCave] Attempting P2P store to peer:', peerId.slice(0, 12) + '...');
-          
-          try {
-            const result = await p2pProtocolClient.storeToPeer(
-              peerId,
-              dataArray,
-              mimeType || 'application/octet-stream',
-              authorization,
-              false, // shouldVerifyOnChain - false for browser test storage
-              hashIdToken
-            );
-
-            if (result.success && result.cid) {
-              console.log('[ByteCave] ✓ P2P store successful:', result.cid);
-              return { 
-                success: true, 
-                cid: result.cid, 
-                peerId 
-              };
-            }
-            
-            console.warn('[ByteCave] ✗ P2P store failed:', result.error);
-          } catch (err: any) {
-            console.error('[ByteCave] ✗ P2P store exception:', err.message);
-          }
-        }
-      }
-      
-      console.log('[ByteCave] P2P storage failed or no peers available, falling back to WebSocket relay');
+    // Use WebSocket relay for storage (browsers cannot use P2P storage protocol)
+    if (!this.config.relayWsUrl) {
+      return { success: false, error: 'WebSocket relay URL not configured' };
     }
 
-    // Fallback to WebSocket relay if P2P fails or node not initialized
-    if (this.config.relayWsUrl) {
-      console.log('[ByteCave] Attempting WebSocket storage via relay (fallback)');
-      
-      try {
-        if (!this.storageWsClient) {
-          this.storageWsClient = new StorageWebSocketClient(this.config.relayWsUrl);
-        }
+    console.log('[ByteCave] Storing 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 (fallback):', result.cid);
-          return {
-            success: true,
-            cid: result.cid,
-            peerId: 'relay-ws'
-          };
-        }
+      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
+      });
 
-        console.warn('[ByteCave] WebSocket storage failed:', result.error);
-      } catch (err: any) {
-        console.warn('[ByteCave] WebSocket storage exception:', err.message);
+      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:', result.error);
+      return { success: false, error: result.error || 'WebSocket storage failed' };
+    } catch (err: any) {
+      console.error('[ByteCave] WebSocket storage exception:', err.message);
+      return { success: false, error: err.message };
     }
-    
-    return { success: false, error: 'All storage methods failed (P2P and WebSocket relay)' };
   }
 
   /**