@gethashd/bytecave-browser 1.0.37 → 1.0.39

package/dist/{chunk-544OXLKK.js → chunk-SIGWRCA5.js}

@@ -6133,6 +6133,7 @@ var StorageWebSocketClient = class {
       requestId,
       data: base64Data,
       contentType: options.contentType,
+      hashIdToken: options.hashIdToken,
       authorization: options.authorization
     };
     return new Promise((resolve, reject) => {
@@ -6223,7 +6224,17 @@ var ByteCaveClient = class {
       console.log("[ByteCave] Bootstrap peers:", bootstrapPeers);
       this.node = await createLibp2p({
         transports: [
-          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" }
+              ]
+            }
+          }),
           webSockets(),
           circuitRelayTransport()
         ],
@@ -6533,8 +6544,44 @@ 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) {
-      console.log("[ByteCave] Attempting WebSocket storage via relay");
+      console.log("[ByteCave] Attempting WebSocket storage via relay (fallback)");
       try {
         if (!this.storageWsClient) {
           this.storageWsClient = new StorageWebSocketClient(this.config.relayWsUrl);
@@ -6550,11 +6597,12 @@ Nonce: ${nonce}`;
         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);
+          console.log("[ByteCave] \u2713 WebSocket storage successful (fallback):", result.cid);
           return {
             success: true,
             cid: result.cid,
@@ -6566,50 +6614,7 @@ Nonce: ${nonce}`;
         console.warn("[ByteCave] WebSocket storage exception:", err.message);
       }
     }
-    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.error("[ByteCave] All storage methods failed. Errors:", errors);
-    return { success: false, error: `All storage methods failed: ${errors.join("; ")}` };
+    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

@@ -6186,6 +6186,7 @@ var StorageWebSocketClient = class {
       requestId,
       data: base64Data,
       contentType: options.contentType,
+      hashIdToken: options.hashIdToken,
       authorization: options.authorization
     };
     return new Promise((resolve, reject) => {
@@ -6276,7 +6277,17 @@ var ByteCaveClient = class {
       console.log("[ByteCave] Bootstrap peers:", bootstrapPeers);
       this.node = await (0, import_libp2p.createLibp2p)({
         transports: [
-          (0, import_webrtc.webRTC)(),
+          (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_websockets.webSockets)(),
           (0, import_circuit_relay_v2.circuitRelayTransport)()
         ],
@@ -6586,8 +6597,44 @@ 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) {
-      console.log("[ByteCave] Attempting WebSocket storage via relay");
+      console.log("[ByteCave] Attempting WebSocket storage via relay (fallback)");
       try {
         if (!this.storageWsClient) {
           this.storageWsClient = new StorageWebSocketClient(this.config.relayWsUrl);
@@ -6603,11 +6650,12 @@ Nonce: ${nonce}`;
         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);
+          console.log("[ByteCave] \u2713 WebSocket storage successful (fallback):", result.cid);
           return {
             success: true,
             cid: result.cid,
@@ -6619,50 +6667,7 @@ Nonce: ${nonce}`;
         console.warn("[ByteCave] WebSocket storage exception:", err.message);
       }
     }
-    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.error("[ByteCave] All storage methods failed. Errors:", errors);
-    return { success: false, error: `All storage methods failed: ${errors.join("; ")}` };
+    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-544OXLKK.js";
+} from "./chunk-SIGWRCA5.js";
 import {
   clearHashdCache,
   createHashdUrl,

package/dist/react/index.js

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

package/dist/storage-websocket.d.ts

@@ -5,6 +5,7 @@
 export interface StoreViaWebSocketOptions {
     data: Uint8Array;
     contentType: string;
+    hashIdToken?: number;
     authorization?: {
         signature: string;
         address: string;

package/package.json

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

package/src/client.ts

@@ -99,7 +99,17 @@ export class ByteCaveClient {
       // Create libp2p node with WebRTC transport
       this.node = await createLibp2p({
         transports: [
-          webRTC() as any,
+          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,
           webSockets() as any,
           circuitRelayTransport() as any
         ],
@@ -476,9 +486,60 @@ Nonce: ${nonce}`;
       }
     }
 
-    // Try WebSocket storage first if relay WS URL is configured
+    // 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');
+    }
+
+    // Fallback to WebSocket relay if P2P fails or node not initialized
     if (this.config.relayWsUrl) {
-      console.log('[ByteCave] Attempting WebSocket storage via relay');
+      console.log('[ByteCave] Attempting WebSocket storage via relay (fallback)');
       
       try {
         if (!this.storageWsClient) {
@@ -497,12 +558,13 @@ Nonce: ${nonce}`;
         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);
+          console.log('[ByteCave] ✓ WebSocket storage successful (fallback):', result.cid);
           return {
             success: true,
             cid: result.cid,
@@ -515,68 +577,8 @@ Nonce: ${nonce}`;
         console.warn('[ByteCave] WebSocket storage exception:', err.message);
       }
     }
-
-    // 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' };
-    }
-    
-    // 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
-        );
-
-        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);
-      }
-    }
     
-    console.error('[ByteCave] All storage methods failed. Errors:', errors);
-    return { success: false, error: `All storage methods failed: ${errors.join('; ')}` };
+    return { success: false, error: 'All storage methods failed (P2P and WebSocket relay)' };
   }
 
   /**

package/src/storage-websocket.ts

@@ -8,6 +8,7 @@ interface StorageRequestMessage {
   requestId: string;
   data: string; // base64
   contentType: string;
+  hashIdToken?: number;
   authorization?: {
     signature: string;
     address: string;
@@ -31,6 +32,7 @@ type Message = StorageRequestMessage | StorageResponseMessage;
 export interface StoreViaWebSocketOptions {
   data: Uint8Array;
   contentType: string;
+  hashIdToken?: number;
   authorization?: {
     signature: string;
     address: string;
@@ -124,6 +126,7 @@ export class StorageWebSocketClient {
       requestId,
       data: base64Data,
       contentType: options.contentType,
+      hashIdToken: options.hashIdToken,
       authorization: options.authorization
     };