@gethashd/bytecave-browser 1.0.40 → 1.0.42

package/dist/{chunk-IXGM3WHR.js → chunk-P7BUV66R.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;
   }
@@ -6573,51 +6615,32 @@ Nonce: ${nonce}`;
     }
   }
   /**
-   * 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)
@@ -7362,7 +7385,7 @@ function useHashdUrl(hashdUrl) {
         URL.revokeObjectURL(blobUrl);
       }
     };
-  }, [hashdUrl, retrieve]);
+  }, [hashdUrl]);
   return { blobUrl, loading, error };
 }
 

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;
   }
@@ -6626,51 +6668,32 @@ Nonce: ${nonce}`;
     }
   }
   /**
-   * 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)
@@ -7557,7 +7580,7 @@ function useHashdUrl(hashdUrl) {
         URL.revokeObjectURL(blobUrl);
       }
     };
-  }, [hashdUrl, retrieve]);
+  }, [hashdUrl]);
   return { blobUrl, loading, error };
 }
 

package/dist/index.js

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

package/dist/react/index.cjs

@@ -6426,7 +6426,7 @@ function useHashdUrl(hashdUrl) {
         URL.revokeObjectURL(blobUrl);
       }
     };
-  }, [hashdUrl, retrieve]);
+  }, [hashdUrl]);
   return { blobUrl, loading, error };
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/react/index.js

@@ -8,7 +8,7 @@ import {
   useHashdImage,
   useHashdMedia,
   useHashdUrl
-} from "../chunk-IXGM3WHR.js";
+} from "../chunk-P7BUV66R.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.40",
+  "version": "1.0.42",
   "description": "ByteCave browser client for WebRTC P2P connections to storage nodes",
   "main": "dist/index.cjs",
   "module": "dist/index.js",

package/src/client.ts

@@ -523,66 +523,37 @@ Nonce: ${nonce}`;
   }
 
   /**
-   * 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' };
-    }
-
-    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' };
+    if (!this.config.relayWsUrl) {
+      return { success: false, error: 'WebSocket relay URL not configured' };
     }
 
-    // Find which peers have this CID
-    const peersWithCid: string[] = [];
+    console.log('[ByteCave] Retrieving via WebSocket relay, CID:', cid);
     
-    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/react/useHashdUrl.ts

@@ -62,7 +62,7 @@ export function useHashdUrl(hashdUrl: string | null | undefined): UseHashdUrlRes
         URL.revokeObjectURL(blobUrl);
       }
     };
-  }, [hashdUrl, retrieve]);
+  }, [hashdUrl]); // eslint-disable-line react-hooks/exhaustive-deps
 
   return { blobUrl, loading, error };
 }

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;
   }