@gethashd/bytecave-browser 1.0.38 → 1.0.40

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

@@ -6534,84 +6534,43 @@ Nonce: ${nonce}`;
         console.warn("[ByteCave] Failed to create authorization:", err.message);
       }
     }
-    if (this.config.relayWsUrl) {
-      console.log("[ByteCave] Attempting WebSocket storage via 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);
-      } catch (err) {
-        console.warn("[ByteCave] WebSocket storage exception:", err.message);
-      }
+    if (!this.config.relayWsUrl) {
+      return { success: false, error: "WebSocket relay URL not configured" };
     }
-    if (!this.node) {
-      return { success: false, error: "WebSocket storage failed and P2P node not initialized" };
-    }
-    console.log("[ByteCave] Falling back to P2P storage");
-    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) {
-      return { success: false, error: "WebSocket storage failed and no P2P peers available" };
-    }
-    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;
-    const errors = [];
-    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
-          };
-        }
-        const errorMsg = `${peerId.slice(0, 12)}: ${result.error}`;
-        console.warn("[ByteCave] \u2717 P2P store failed:", errorMsg);
-        errors.push(errorMsg);
-      } catch (err) {
-        const errorMsg = `${peerId.slice(0, 12)}: ${err.message}`;
-        console.error("[ByteCave] \u2717 P2P store exception:", errorMsg);
-        errors.push(errorMsg);
+    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 };
     }
-    console.error("[ByteCave] All storage methods failed. Errors:", errors);
-    return { success: false, error: `All storage methods failed: ${errors.join("; ")}` };
   }
   /**
    * Retrieve ciphertext from a node via P2P only (no HTTP fallback)

package/dist/index.cjs

@@ -6587,84 +6587,43 @@ Nonce: ${nonce}`;
         console.warn("[ByteCave] Failed to create authorization:", err.message);
       }
     }
-    if (this.config.relayWsUrl) {
-      console.log("[ByteCave] Attempting WebSocket storage via 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);
-      } catch (err) {
-        console.warn("[ByteCave] WebSocket storage exception:", err.message);
-      }
+    if (!this.config.relayWsUrl) {
+      return { success: false, error: "WebSocket relay URL not configured" };
     }
-    if (!this.node) {
-      return { success: false, error: "WebSocket storage failed and P2P node not initialized" };
-    }
-    console.log("[ByteCave] Falling back to P2P storage");
-    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) {
-      return { success: false, error: "WebSocket storage failed and no P2P peers available" };
-    }
-    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;
-    const errors = [];
-    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
-          };
-        }
-        const errorMsg = `${peerId.slice(0, 12)}: ${result.error}`;
-        console.warn("[ByteCave] \u2717 P2P store failed:", errorMsg);
-        errors.push(errorMsg);
-      } catch (err) {
-        const errorMsg = `${peerId.slice(0, 12)}: ${err.message}`;
-        console.error("[ByteCave] \u2717 P2P store exception:", errorMsg);
-        errors.push(errorMsg);
+    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 };
     }
-    console.error("[ByteCave] All storage methods failed. Errors:", errors);
-    return { success: false, error: `All storage methods failed: ${errors.join("; ")}` };
   }
   /**
    * 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-CIBPIU23.js";
+} from "./chunk-IXGM3WHR.js";
 import {
   clearHashdCache,
   createHashdUrl,

package/dist/react/index.js

@@ -8,7 +8,7 @@ import {
   useHashdImage,
   useHashdMedia,
   useHashdUrl
-} from "../chunk-CIBPIU23.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.38",
+  "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

@@ -476,108 +476,50 @@ Nonce: ${nonce}`;
       }
     }
 
-    // Try WebSocket storage first if relay WS URL is configured
-    if (this.config.relayWsUrl) {
-      console.log('[ByteCave] Attempting WebSocket storage via 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:', result.error);
-      } catch (err: any) {
-        console.warn('[ByteCave] WebSocket storage exception:', err.message);
-      }
+    // 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 P2P storage
-    if (!this.node) {
-      return { success: false, error: 'WebSocket storage failed and P2P node not initialized' };
-    }
-
-    console.log('[ByteCave] Falling back to P2P storage');
-    
-    // Get all connected peers
-    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) {
-      return { success: false, error: 'WebSocket storage failed and no P2P peers available' };
-    }
+    console.log('[ByteCave] Storing via WebSocket relay');
     
-    // 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;
-    
-    const errors: string[] = [];
-    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
-        );
+    try {
+      if (!this.storageWsClient) {
+        this.storageWsClient = new StorageWebSocketClient(this.config.relayWsUrl);
+      }
 
-        if (result.success && result.cid) {
-          console.log('[ByteCave] ✓ P2P store successful:', result.cid);
-          return { 
-            success: true, 
-            cid: result.cid, 
-            peerId 
-          };
-        }
-        
-        const errorMsg = `${peerId.slice(0, 12)}: ${result.error}`;
-        console.warn('[ByteCave] ✗ P2P store failed:', errorMsg);
-        errors.push(errorMsg);
-      } catch (err: any) {
-        const errorMsg = `${peerId.slice(0, 12)}: ${err.message}`;
-        console.error('[ByteCave] ✗ P2P store exception:', errorMsg);
-        errors.push(errorMsg);
+      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:', 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 };
     }
-    
-    console.error('[ByteCave] All storage methods failed. Errors:', errors);
-    return { success: false, error: `All storage methods failed: ${errors.join('; ')}` };
   }
 
   /**