@gethashd/bytecave-browser 1.0.39 → 1.0.41

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

@@ -6120,6 +6120,22 @@ var StorageWebSocketClient = class {
           pending.resolve({ success: false, error: message2.error || "Storage failed" });
         }
       }
+    } else if (message2.type === "retrieve-response") {
+      const pending = this.pendingRequests.get(message2.requestId);
+      if (pending) {
+        clearTimeout(pending.timeout);
+        this.pendingRequests.delete(message2.requestId);
+        if (message2.success && message2.data) {
+          const binaryString = atob(message2.data);
+          const bytes = new Uint8Array(binaryString.length);
+          for (let i = 0; i < binaryString.length; i++) {
+            bytes[i] = binaryString.charCodeAt(i);
+          }
+          pending.resolve({ success: true, data: bytes, mimeType: message2.mimeType });
+        } else {
+          pending.resolve({ success: false, error: message2.error || "Retrieval failed" });
+        }
+      }
     }
   }
   async store(options) {
@@ -6163,6 +6179,32 @@ var StorageWebSocketClient = class {
     }
     this.pendingRequests.clear();
   }
+  async retrieve(cid, timeout = 3e4) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      await this.connect();
+    }
+    const requestId = Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+    const request = {
+      type: "retrieve-request",
+      requestId,
+      cid
+    };
+    return new Promise((resolve, reject) => {
+      const timeoutHandle = setTimeout(() => {
+        this.pendingRequests.delete(requestId);
+        reject(new Error("Retrieval request timeout"));
+      }, timeout);
+      this.pendingRequests.set(requestId, { resolve, reject, timeout: timeoutHandle });
+      try {
+        this.ws.send(JSON.stringify(request));
+        console.log("[Storage WS] Sent retrieval request:", requestId, "CID:", cid);
+      } catch (error) {
+        clearTimeout(timeoutHandle);
+        this.pendingRequests.delete(requestId);
+        reject(error);
+      }
+    });
+  }
   isConnected() {
     return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
   }
@@ -6224,17 +6266,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,124 +6576,71 @@ 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)
+   * Retrieve ciphertext from a node via WebSocket relay
    */
   async retrieve(cid) {
-    if (!this.node) {
-      console.error("[ByteCave] Retrieve failed: P2P node not initialized");
-      return { success: false, error: "P2P node not initialized" };
+    if (!this.config.relayWsUrl) {
+      return { success: false, error: "WebSocket relay URL not configured" };
     }
-    const libp2pPeers = this.node.getPeers();
-    console.log("[ByteCave] Retrieve - libp2p peers:", libp2pPeers.length);
-    console.log("[ByteCave] Retrieve - known peers:", this.knownPeers.size);
-    console.log("[ByteCave] Retrieve - node status:", this.node.status);
-    if (libp2pPeers.length === 0) {
-      console.warn("[ByteCave] Retrieve failed: No libp2p peers connected, but have", this.knownPeers.size, "known peers");
-      return { success: false, error: "No connected peers available" };
-    }
-    const peersWithCid = [];
-    for (const peerId of libp2pPeers) {
-      const peerIdStr = peerId.toString();
-      try {
-        const hasCid = await p2pProtocolClient.peerHasCid(peerIdStr, cid);
-        if (hasCid) {
-          peersWithCid.push(peerIdStr);
-        }
-      } catch (error) {
+    console.log("[ByteCave] Retrieving via WebSocket relay, CID:", cid);
+    try {
+      if (!this.storageWsClient) {
+        this.storageWsClient = new StorageWebSocketClient(this.config.relayWsUrl);
       }
-    }
-    if (peersWithCid.length === 0) {
-      return { success: false, error: "Blob not found on any connected peer" };
-    }
-    for (const peerId of peersWithCid) {
-      try {
-        const timeoutPromise = new Promise(
-          (_, reject) => setTimeout(() => reject(new Error("Retrieval timeout after 10s")), 1e4)
-        );
-        const result = await Promise.race([
-          p2pProtocolClient.retrieveFromPeer(peerId, cid),
-          timeoutPromise
-        ]);
-        if (result) {
-          return { success: true, data: result.data, peerId };
-        }
-      } catch (error) {
+      const result = await this.storageWsClient.retrieve(cid, 3e4);
+      if (result.success && result.data) {
+        console.log("[ByteCave] \u2713 WebSocket retrieval successful:", cid);
+        return {
+          success: true,
+          data: result.data,
+          peerId: "relay-ws"
+        };
       }
+      console.warn("[ByteCave] WebSocket retrieval failed:", result.error);
+      return { success: false, error: result.error || "Retrieval failed" };
+    } catch (err) {
+      console.error("[ByteCave] WebSocket retrieval exception:", err.message);
+      return { success: false, error: err.message };
     }
-    return { success: false, error: "Failed to retrieve blob from peers that have it" };
   }
   /**
    * Register content in ContentRegistry contract (on-chain)

package/dist/client.d.ts

@@ -39,7 +39,7 @@ export declare class ByteCaveClient {
      */
     store(data: Uint8Array | ArrayBuffer, mimeType?: string, signer?: any, hashIdToken?: number): Promise<StoreResult>;
     /**
-     * Retrieve ciphertext from a node via P2P only (no HTTP fallback)
+     * Retrieve ciphertext from a node via WebSocket relay
      */
     retrieve(cid: string): Promise<RetrieveResult>;
     /**

package/dist/index.cjs

@@ -6173,6 +6173,22 @@ var StorageWebSocketClient = class {
           pending.resolve({ success: false, error: message2.error || "Storage failed" });
         }
       }
+    } else if (message2.type === "retrieve-response") {
+      const pending = this.pendingRequests.get(message2.requestId);
+      if (pending) {
+        clearTimeout(pending.timeout);
+        this.pendingRequests.delete(message2.requestId);
+        if (message2.success && message2.data) {
+          const binaryString = atob(message2.data);
+          const bytes = new Uint8Array(binaryString.length);
+          for (let i = 0; i < binaryString.length; i++) {
+            bytes[i] = binaryString.charCodeAt(i);
+          }
+          pending.resolve({ success: true, data: bytes, mimeType: message2.mimeType });
+        } else {
+          pending.resolve({ success: false, error: message2.error || "Retrieval failed" });
+        }
+      }
     }
   }
   async store(options) {
@@ -6216,6 +6232,32 @@ var StorageWebSocketClient = class {
     }
     this.pendingRequests.clear();
   }
+  async retrieve(cid, timeout = 3e4) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      await this.connect();
+    }
+    const requestId = Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+    const request = {
+      type: "retrieve-request",
+      requestId,
+      cid
+    };
+    return new Promise((resolve, reject) => {
+      const timeoutHandle = setTimeout(() => {
+        this.pendingRequests.delete(requestId);
+        reject(new Error("Retrieval request timeout"));
+      }, timeout);
+      this.pendingRequests.set(requestId, { resolve, reject, timeout: timeoutHandle });
+      try {
+        this.ws.send(JSON.stringify(request));
+        console.log("[Storage WS] Sent retrieval request:", requestId, "CID:", cid);
+      } catch (error) {
+        clearTimeout(timeoutHandle);
+        this.pendingRequests.delete(requestId);
+        reject(error);
+      }
+    });
+  }
   isConnected() {
     return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
   }
@@ -6277,17 +6319,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,124 +6629,71 @@ 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)
+   * Retrieve ciphertext from a node via WebSocket relay
    */
   async retrieve(cid) {
-    if (!this.node) {
-      console.error("[ByteCave] Retrieve failed: P2P node not initialized");
-      return { success: false, error: "P2P node not initialized" };
+    if (!this.config.relayWsUrl) {
+      return { success: false, error: "WebSocket relay URL not configured" };
     }
-    const libp2pPeers = this.node.getPeers();
-    console.log("[ByteCave] Retrieve - libp2p peers:", libp2pPeers.length);
-    console.log("[ByteCave] Retrieve - known peers:", this.knownPeers.size);
-    console.log("[ByteCave] Retrieve - node status:", this.node.status);
-    if (libp2pPeers.length === 0) {
-      console.warn("[ByteCave] Retrieve failed: No libp2p peers connected, but have", this.knownPeers.size, "known peers");
-      return { success: false, error: "No connected peers available" };
-    }
-    const peersWithCid = [];
-    for (const peerId of libp2pPeers) {
-      const peerIdStr = peerId.toString();
-      try {
-        const hasCid = await p2pProtocolClient.peerHasCid(peerIdStr, cid);
-        if (hasCid) {
-          peersWithCid.push(peerIdStr);
-        }
-      } catch (error) {
+    console.log("[ByteCave] Retrieving via WebSocket relay, CID:", cid);
+    try {
+      if (!this.storageWsClient) {
+        this.storageWsClient = new StorageWebSocketClient(this.config.relayWsUrl);
       }
-    }
-    if (peersWithCid.length === 0) {
-      return { success: false, error: "Blob not found on any connected peer" };
-    }
-    for (const peerId of peersWithCid) {
-      try {
-        const timeoutPromise = new Promise(
-          (_, reject) => setTimeout(() => reject(new Error("Retrieval timeout after 10s")), 1e4)
-        );
-        const result = await Promise.race([
-          p2pProtocolClient.retrieveFromPeer(peerId, cid),
-          timeoutPromise
-        ]);
-        if (result) {
-          return { success: true, data: result.data, peerId };
-        }
-      } catch (error) {
+      const result = await this.storageWsClient.retrieve(cid, 3e4);
+      if (result.success && result.data) {
+        console.log("[ByteCave] \u2713 WebSocket retrieval successful:", cid);
+        return {
+          success: true,
+          data: result.data,
+          peerId: "relay-ws"
+        };
       }
+      console.warn("[ByteCave] WebSocket retrieval failed:", result.error);
+      return { success: false, error: result.error || "Retrieval failed" };
+    } catch (err) {
+      console.error("[ByteCave] WebSocket retrieval exception:", err.message);
+      return { success: false, error: err.message };
     }
-    return { success: false, error: "Failed to retrieve blob from peers that have it" };
   }
   /**
    * Register content in ContentRegistry contract (on-chain)

package/dist/index.js

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

package/dist/react/index.js

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

package/dist/storage-websocket.d.ts

@@ -29,5 +29,11 @@ export declare class StorageWebSocketClient {
         error?: string;
     }>;
     disconnect(): void;
+    retrieve(cid: string, timeout?: number): Promise<{
+        success: boolean;
+        data?: Uint8Array;
+        mimeType?: string;
+        error?: string;
+    }>;
     isConnected(): boolean;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gethashd/bytecave-browser",
-  "version": "1.0.39",
+  "version": "1.0.41",
   "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,162 +476,84 @@ 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)' };
   }
 
   /**
-   * Retrieve ciphertext from a node via P2P only (no HTTP fallback)
+   * Retrieve ciphertext from a node via WebSocket relay
    */
   async retrieve(cid: string): Promise<RetrieveResult> {
-    if (!this.node) {
-      console.error('[ByteCave] Retrieve failed: P2P node not initialized');
-      return { success: false, error: 'P2P node not initialized' };
+    if (!this.config.relayWsUrl) {
+      return { success: false, error: 'WebSocket relay URL not configured' };
     }
 
-    const libp2pPeers = this.node.getPeers();
-    console.log('[ByteCave] Retrieve - libp2p peers:', libp2pPeers.length);
-    console.log('[ByteCave] Retrieve - known peers:', this.knownPeers.size);
-    console.log('[ByteCave] Retrieve - node status:', this.node.status);
+    console.log('[ByteCave] Retrieving via WebSocket relay, CID:', cid);
     
-    if (libp2pPeers.length === 0) {
-      console.warn('[ByteCave] Retrieve failed: No libp2p peers connected, but have', this.knownPeers.size, 'known peers');
-      return { success: false, error: 'No connected peers available' };
-    }
-
-    // Find which peers have this CID
-    const peersWithCid: string[] = [];
-    
-    for (const peerId of libp2pPeers) {
-      const peerIdStr = peerId.toString();
-      
-      try {
-        const hasCid = await p2pProtocolClient.peerHasCid(peerIdStr, cid);
-        
-        if (hasCid) {
-          peersWithCid.push(peerIdStr);
-        }
-      } catch (error: any) {
-        // Skip peers that don't support the protocol
+    try {
+      if (!this.storageWsClient) {
+        this.storageWsClient = new StorageWebSocketClient(this.config.relayWsUrl);
       }
-    }
 
-    if (peersWithCid.length === 0) {
-      return { success: false, error: 'Blob not found on any connected peer' };
-    }
+      const result = await this.storageWsClient.retrieve(cid, 30000);
 
-    // Try to retrieve from peers that have the CID
-    for (const peerId of peersWithCid) {
-      try {
-        const timeoutPromise = new Promise<null>((_, reject) => 
-          setTimeout(() => reject(new Error('Retrieval timeout after 10s')), 10000)
-        );
-        
-        const result = await Promise.race([
-          p2pProtocolClient.retrieveFromPeer(peerId, cid),
-          timeoutPromise
-        ]);
-        
-        if (result) {
-          return { success: true, data: result.data, peerId };
-        }
-      } catch (error: any) {
-        // Continue to next peer
+      if (result.success && result.data) {
+        console.log('[ByteCave] ✓ WebSocket retrieval successful:', cid);
+        return {
+          success: true,
+          data: result.data,
+          peerId: 'relay-ws'
+        };
       }
-    }
 
-    return { success: false, error: 'Failed to retrieve blob from peers that have it' };
+      console.warn('[ByteCave] WebSocket retrieval failed:', result.error);
+      return { success: false, error: result.error || 'Retrieval failed' };
+    } catch (err: any) {
+      console.error('[ByteCave] WebSocket retrieval exception:', err.message);
+      return { success: false, error: err.message };
+    }
   }
 
   /**

package/src/storage-websocket.ts

@@ -27,7 +27,22 @@ interface StorageResponseMessage {
   error?: string;
 }
 
-type Message = StorageRequestMessage | StorageResponseMessage;
+interface RetrieveRequestMessage {
+  type: 'retrieve-request';
+  requestId: string;
+  cid: string;
+}
+
+interface RetrieveResponseMessage {
+  type: 'retrieve-response';
+  requestId: string;
+  success: boolean;
+  data?: string; // base64
+  mimeType?: string;
+  error?: string;
+}
+
+type Message = StorageRequestMessage | StorageResponseMessage | RetrieveRequestMessage | RetrieveResponseMessage;
 
 export interface StoreViaWebSocketOptions {
   data: Uint8Array;
@@ -47,7 +62,7 @@ export interface StoreViaWebSocketOptions {
 export class StorageWebSocketClient {
   private ws: WebSocket | null = null;
   private pendingRequests: Map<string, {
-    resolve: (result: { success: boolean; cid?: string; error?: string }) => void;
+    resolve: (result: any) => void;
     reject: (error: Error) => void;
     timeout: NodeJS.Timeout;
   }> = new Map();
@@ -107,6 +122,24 @@ export class StorageWebSocketClient {
           pending.resolve({ success: false, error: message.error || 'Storage failed' });
         }
       }
+    } else if (message.type === 'retrieve-response') {
+      const pending = this.pendingRequests.get(message.requestId);
+      if (pending) {
+        clearTimeout(pending.timeout);
+        this.pendingRequests.delete(message.requestId);
+        
+        if (message.success && message.data) {
+          // Convert base64 to Uint8Array
+          const binaryString = atob(message.data);
+          const bytes = new Uint8Array(binaryString.length);
+          for (let i = 0; i < binaryString.length; i++) {
+            bytes[i] = binaryString.charCodeAt(i);
+          }
+          pending.resolve({ success: true, data: bytes, mimeType: message.mimeType });
+        } else {
+          pending.resolve({ success: false, error: message.error || 'Retrieval failed' });
+        }
+      }
     }
   }
 
@@ -163,6 +196,39 @@ export class StorageWebSocketClient {
     this.pendingRequests.clear();
   }
 
+  async retrieve(cid: string, timeout: number = 30000): Promise<{ success: boolean; data?: Uint8Array; mimeType?: string; error?: string }> {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      await this.connect();
+    }
+
+    const requestId = Math.random().toString(36).substring(2, 15) + 
+                      Math.random().toString(36).substring(2, 15);
+
+    const request: RetrieveRequestMessage = {
+      type: 'retrieve-request',
+      requestId,
+      cid
+    };
+
+    return new Promise((resolve, reject) => {
+      const timeoutHandle = setTimeout(() => {
+        this.pendingRequests.delete(requestId);
+        reject(new Error('Retrieval request timeout'));
+      }, timeout);
+
+      this.pendingRequests.set(requestId, { resolve, reject, timeout: timeoutHandle });
+
+      try {
+        this.ws!.send(JSON.stringify(request));
+        console.log('[Storage WS] Sent retrieval request:', requestId, 'CID:', cid);
+      } catch (error: any) {
+        clearTimeout(timeoutHandle);
+        this.pendingRequests.delete(requestId);
+        reject(error);
+      }
+    });
+  }
+
   isConnected(): boolean {
     return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
   }