@gethashd/bytecave-browser 1.0.47 → 1.0.48

package/dist/{chunk-FOQ3CE3H.js → chunk-FSNCYF3O.js}

@@ -6226,6 +6226,101 @@ var StorageWebSocketClient = class {
   }
 };
 
+// src/storage-webtransport.ts
+var StorageWebTransportClient = class {
+  constructor(nodeMultiaddr) {
+    this.nodeMultiaddr = nodeMultiaddr;
+  }
+  /**
+   * Store data via WebTransport direct to node
+   */
+  async store(request) {
+    try {
+      if (typeof WebTransport === "undefined") {
+        return {
+          success: false,
+          error: "WebTransport not supported in this browser"
+        };
+      }
+      const url = this.multiaddrToWebTransportUrl(this.nodeMultiaddr);
+      if (!url) {
+        return {
+          success: false,
+          error: "Invalid WebTransport multiaddr"
+        };
+      }
+      console.log("[WebTransport] Connecting to node:", url);
+      const transport = new WebTransport(url);
+      await transport.ready;
+      console.log("[WebTransport] Connected, opening bidirectional stream");
+      const stream = await transport.createBidirectionalStream();
+      const writer = stream.writable.getWriter();
+      const reader = stream.readable.getReader();
+      const requestData = {
+        type: "storage-request",
+        data: Array.from(request.data),
+        // Convert Uint8Array to array for JSON
+        contentType: request.contentType,
+        hashIdToken: request.hashIdToken,
+        authorization: request.authorization
+      };
+      const requestJson = JSON.stringify(requestData);
+      const requestBytes = new TextEncoder().encode(requestJson);
+      await writer.write(requestBytes);
+      await writer.close();
+      console.log("[WebTransport] Request sent, waiting for response");
+      const { value, done } = await reader.read();
+      if (done || !value) {
+        return {
+          success: false,
+          error: "No response from node"
+        };
+      }
+      const responseJson = new TextDecoder().decode(value);
+      const response = JSON.parse(responseJson);
+      console.log("[WebTransport] Response received:", response);
+      await transport.close();
+      return response;
+    } catch (error) {
+      console.error("[WebTransport] Storage failed:", error);
+      return {
+        success: false,
+        error: error.message || "WebTransport storage failed"
+      };
+    }
+  }
+  /**
+   * Convert libp2p multiaddr to WebTransport URL
+   */
+  multiaddrToWebTransportUrl(multiaddr2) {
+    try {
+      const parts = multiaddr2.split("/").filter((p) => p);
+      let ip = "";
+      let port = "";
+      let hasQuic = false;
+      let hasWebTransport = false;
+      for (let i = 0; i < parts.length; i++) {
+        if (parts[i] === "ip4" && i + 1 < parts.length) {
+          ip = parts[i + 1];
+        } else if (parts[i] === "udp" && i + 1 < parts.length) {
+          port = parts[i + 1];
+        } else if (parts[i] === "quic-v1") {
+          hasQuic = true;
+        } else if (parts[i] === "webtransport") {
+          hasWebTransport = true;
+        }
+      }
+      if (!ip || !port || !hasQuic || !hasWebTransport) {
+        return null;
+      }
+      return `https://${ip}:${port}`;
+    } catch (error) {
+      console.error("[WebTransport] Failed to parse multiaddr:", error);
+      return null;
+    }
+  }
+};
+
 // src/contracts/ContentRegistry.ts
 var CONTENT_REGISTRY_ABI = [
   "function registerContent(bytes32 cid, address owner, bytes32 appId, uint256 hashIdToken) external",
@@ -6591,15 +6686,76 @@ Nonce: ${nonce}`;
         console.warn("[ByteCave] Failed to create authorization:", err.message);
       }
     }
-    if (!this.config.relayWsUrl) {
-      return { success: false, error: "WebSocket relay URL not configured" };
+    if (this.config.relayWsUrl) {
+      console.log("[ByteCave] Attempting storage 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, trying WebTransport:", result.error);
+      } catch (err) {
+        console.warn("[ByteCave] WebSocket storage exception, trying WebTransport:", err.message);
+      }
+    } else {
+      console.log("[ByteCave] WebSocket relay not configured, trying WebTransport");
     }
-    console.log("[ByteCave] Storing via WebSocket relay");
+    console.log("[ByteCave] Attempting storage via WebTransport direct");
     try {
-      if (!this.storageWsClient) {
-        this.storageWsClient = new StorageWebSocketClient(this.config.relayWsUrl);
+      let nodes = [];
+      if (this.relayDiscovery) {
+        nodes = await this.relayDiscovery.getConnectedPeers();
+      } else if (this.contractDiscovery) {
+        nodes = await this.contractDiscovery.getActiveNodes();
+      }
+      if (nodes.length === 0) {
+        return {
+          success: false,
+          error: "No nodes available for WebTransport storage"
+        };
+      }
+      const nodeWithWebTransport = nodes.find(
+        (node) => node.multiaddrs?.some((addr) => addr.includes("/webtransport"))
+      );
+      if (!nodeWithWebTransport || !nodeWithWebTransport.multiaddrs) {
+        return {
+          success: false,
+          error: "No nodes with WebTransport support found"
+        };
       }
-      const wsAuth = authorization ? {
+      const wtMultiaddr = nodeWithWebTransport.multiaddrs.find(
+        (addr) => addr.includes("/webtransport")
+      );
+      if (!wtMultiaddr) {
+        return {
+          success: false,
+          error: "No WebTransport multiaddr found"
+        };
+      }
+      const wtClient = new StorageWebTransportClient(wtMultiaddr);
+      const wtAuth = authorization ? {
         signature: authorization.signature,
         address: authorization.sender,
         timestamp: authorization.timestamp,
@@ -6607,26 +6763,25 @@ Nonce: ${nonce}`;
         appId: authorization.appId,
         contentHash: authorization.contentHash
       } : void 0;
-      const result = await this.storageWsClient.store({
+      const result = await wtClient.store({
         data: dataArray,
         contentType: mimeType || "application/octet-stream",
         hashIdToken,
-        authorization: wsAuth,
-        timeout: 3e4
+        authorization: wtAuth
       });
       if (result.success && result.cid) {
-        console.log("[ByteCave] \u2713 WebSocket storage successful:", result.cid);
+        console.log("[ByteCave] \u2713 WebTransport storage successful:", result.cid);
         return {
           success: true,
           cid: result.cid,
-          peerId: "relay-ws"
+          peerId: nodeWithWebTransport.peerId
         };
       }
-      console.warn("[ByteCave] WebSocket storage failed:", result.error);
-      return { success: false, error: result.error || "WebSocket storage failed" };
+      console.error("[ByteCave] WebTransport storage failed:", result.error);
+      return { success: false, error: result.error || "All storage methods failed" };
     } catch (err) {
-      console.error("[ByteCave] WebSocket storage exception:", err.message);
-      return { success: false, error: err.message };
+      console.error("[ByteCave] WebTransport storage exception:", err.message);
+      return { success: false, error: `All storage methods failed: ${err.message}` };
     }
   }
   /**

package/dist/index.cjs

@@ -6279,6 +6279,101 @@ var StorageWebSocketClient = class {
   }
 };
 
+// src/storage-webtransport.ts
+var StorageWebTransportClient = class {
+  constructor(nodeMultiaddr) {
+    this.nodeMultiaddr = nodeMultiaddr;
+  }
+  /**
+   * Store data via WebTransport direct to node
+   */
+  async store(request) {
+    try {
+      if (typeof WebTransport === "undefined") {
+        return {
+          success: false,
+          error: "WebTransport not supported in this browser"
+        };
+      }
+      const url = this.multiaddrToWebTransportUrl(this.nodeMultiaddr);
+      if (!url) {
+        return {
+          success: false,
+          error: "Invalid WebTransport multiaddr"
+        };
+      }
+      console.log("[WebTransport] Connecting to node:", url);
+      const transport = new WebTransport(url);
+      await transport.ready;
+      console.log("[WebTransport] Connected, opening bidirectional stream");
+      const stream = await transport.createBidirectionalStream();
+      const writer = stream.writable.getWriter();
+      const reader = stream.readable.getReader();
+      const requestData = {
+        type: "storage-request",
+        data: Array.from(request.data),
+        // Convert Uint8Array to array for JSON
+        contentType: request.contentType,
+        hashIdToken: request.hashIdToken,
+        authorization: request.authorization
+      };
+      const requestJson = JSON.stringify(requestData);
+      const requestBytes = new TextEncoder().encode(requestJson);
+      await writer.write(requestBytes);
+      await writer.close();
+      console.log("[WebTransport] Request sent, waiting for response");
+      const { value, done } = await reader.read();
+      if (done || !value) {
+        return {
+          success: false,
+          error: "No response from node"
+        };
+      }
+      const responseJson = new TextDecoder().decode(value);
+      const response = JSON.parse(responseJson);
+      console.log("[WebTransport] Response received:", response);
+      await transport.close();
+      return response;
+    } catch (error) {
+      console.error("[WebTransport] Storage failed:", error);
+      return {
+        success: false,
+        error: error.message || "WebTransport storage failed"
+      };
+    }
+  }
+  /**
+   * Convert libp2p multiaddr to WebTransport URL
+   */
+  multiaddrToWebTransportUrl(multiaddr2) {
+    try {
+      const parts = multiaddr2.split("/").filter((p) => p);
+      let ip = "";
+      let port = "";
+      let hasQuic = false;
+      let hasWebTransport = false;
+      for (let i = 0; i < parts.length; i++) {
+        if (parts[i] === "ip4" && i + 1 < parts.length) {
+          ip = parts[i + 1];
+        } else if (parts[i] === "udp" && i + 1 < parts.length) {
+          port = parts[i + 1];
+        } else if (parts[i] === "quic-v1") {
+          hasQuic = true;
+        } else if (parts[i] === "webtransport") {
+          hasWebTransport = true;
+        }
+      }
+      if (!ip || !port || !hasQuic || !hasWebTransport) {
+        return null;
+      }
+      return `https://${ip}:${port}`;
+    } catch (error) {
+      console.error("[WebTransport] Failed to parse multiaddr:", error);
+      return null;
+    }
+  }
+};
+
 // src/contracts/ContentRegistry.ts
 var CONTENT_REGISTRY_ABI = [
   "function registerContent(bytes32 cid, address owner, bytes32 appId, uint256 hashIdToken) external",
@@ -6644,15 +6739,76 @@ Nonce: ${nonce}`;
         console.warn("[ByteCave] Failed to create authorization:", err.message);
       }
     }
-    if (!this.config.relayWsUrl) {
-      return { success: false, error: "WebSocket relay URL not configured" };
+    if (this.config.relayWsUrl) {
+      console.log("[ByteCave] Attempting storage 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, trying WebTransport:", result.error);
+      } catch (err) {
+        console.warn("[ByteCave] WebSocket storage exception, trying WebTransport:", err.message);
+      }
+    } else {
+      console.log("[ByteCave] WebSocket relay not configured, trying WebTransport");
     }
-    console.log("[ByteCave] Storing via WebSocket relay");
+    console.log("[ByteCave] Attempting storage via WebTransport direct");
     try {
-      if (!this.storageWsClient) {
-        this.storageWsClient = new StorageWebSocketClient(this.config.relayWsUrl);
+      let nodes = [];
+      if (this.relayDiscovery) {
+        nodes = await this.relayDiscovery.getConnectedPeers();
+      } else if (this.contractDiscovery) {
+        nodes = await this.contractDiscovery.getActiveNodes();
+      }
+      if (nodes.length === 0) {
+        return {
+          success: false,
+          error: "No nodes available for WebTransport storage"
+        };
+      }
+      const nodeWithWebTransport = nodes.find(
+        (node) => node.multiaddrs?.some((addr) => addr.includes("/webtransport"))
+      );
+      if (!nodeWithWebTransport || !nodeWithWebTransport.multiaddrs) {
+        return {
+          success: false,
+          error: "No nodes with WebTransport support found"
+        };
       }
-      const wsAuth = authorization ? {
+      const wtMultiaddr = nodeWithWebTransport.multiaddrs.find(
+        (addr) => addr.includes("/webtransport")
+      );
+      if (!wtMultiaddr) {
+        return {
+          success: false,
+          error: "No WebTransport multiaddr found"
+        };
+      }
+      const wtClient = new StorageWebTransportClient(wtMultiaddr);
+      const wtAuth = authorization ? {
         signature: authorization.signature,
         address: authorization.sender,
         timestamp: authorization.timestamp,
@@ -6660,26 +6816,25 @@ Nonce: ${nonce}`;
         appId: authorization.appId,
         contentHash: authorization.contentHash
       } : void 0;
-      const result = await this.storageWsClient.store({
+      const result = await wtClient.store({
         data: dataArray,
         contentType: mimeType || "application/octet-stream",
         hashIdToken,
-        authorization: wsAuth,
-        timeout: 3e4
+        authorization: wtAuth
       });
       if (result.success && result.cid) {
-        console.log("[ByteCave] \u2713 WebSocket storage successful:", result.cid);
+        console.log("[ByteCave] \u2713 WebTransport storage successful:", result.cid);
         return {
           success: true,
           cid: result.cid,
-          peerId: "relay-ws"
+          peerId: nodeWithWebTransport.peerId
         };
       }
-      console.warn("[ByteCave] WebSocket storage failed:", result.error);
-      return { success: false, error: result.error || "WebSocket storage failed" };
+      console.error("[ByteCave] WebTransport storage failed:", result.error);
+      return { success: false, error: result.error || "All storage methods failed" };
     } catch (err) {
-      console.error("[ByteCave] WebSocket storage exception:", err.message);
-      return { success: false, error: err.message };
+      console.error("[ByteCave] WebTransport storage exception:", err.message);
+      return { success: false, error: `All storage methods failed: ${err.message}` };
     }
   }
   /**

package/dist/index.js

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

package/dist/react/index.js

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

package/dist/storage-webtransport.d.ts

@@ -0,0 +1,36 @@
+/**
+ * WebTransport Storage Client
+ *
+ * Provides direct browser-to-node storage over WebTransport (HTTP/3)
+ * Used as fallback when WebSocket relay is unavailable
+ */
+export interface WebTransportStorageRequest {
+    data: Uint8Array;
+    contentType: string;
+    hashIdToken?: number;
+    authorization?: {
+        signature: string;
+        address: string;
+        timestamp: number;
+        nonce: string;
+        appId: string;
+        contentHash: string;
+    };
+}
+export interface WebTransportStorageResponse {
+    success: boolean;
+    cid?: string;
+    error?: string;
+}
+export declare class StorageWebTransportClient {
+    private nodeMultiaddr;
+    constructor(nodeMultiaddr: string);
+    /**
+     * Store data via WebTransport direct to node
+     */
+    store(request: WebTransportStorageRequest): Promise<WebTransportStorageResponse>;
+    /**
+     * Convert libp2p multiaddr to WebTransport URL
+     */
+    private multiaddrToWebTransportUrl;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gethashd/bytecave-browser",
-  "version": "1.0.47",
+  "version": "1.0.48",
   "description": "ByteCave browser client for WebRTC P2P connections to storage nodes",
   "main": "dist/index.cjs",
   "module": "dist/index.js",
@@ -45,6 +45,7 @@
     "@libp2p/identify": "^4.0.9",
     "@libp2p/webrtc": "^6.0.10",
     "@libp2p/websockets": "^10.1.2",
+    "@libp2p/webtransport": "^6.0.12",
     "@multiformats/multiaddr": "^13.0.1",
     "ethers": "^6.0.0",
     "libp2p": "^3.1.2",

package/src/client.ts

@@ -21,6 +21,7 @@ import { ethers } from 'ethers';
 import { ContractDiscovery, RelayDiscovery } from './discovery.js';
 import { p2pProtocolClient } from './p2p-protocols.js';
 import { StorageWebSocketClient } from './storage-websocket.js';
+import { StorageWebTransportClient } from './storage-webtransport.js';
 import { CONTENT_REGISTRY_ABI } from './contracts/ContentRegistry.js';
 import type { 
   ByteCaveConfig, 
@@ -476,19 +477,98 @@ Nonce: ${nonce}`;
       }
     }
 
-    // Use WebSocket relay for storage (simpler connection management than direct P2P)
-    if (!this.config.relayWsUrl) {
-      return { success: false, error: 'WebSocket relay URL not configured' };
+    // Storage fallback strategy:
+    // 1. Try WebSocket relay (most reliable)
+    // 2. If relay fails, try WebTransport direct to node
+    
+    // Try WebSocket relay first
+    if (this.config.relayWsUrl) {
+      console.log('[ByteCave] Attempting storage 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:', result.cid);
+          return {
+            success: true,
+            cid: result.cid,
+            peerId: 'relay-ws'
+          };
+        }
+
+        console.warn('[ByteCave] WebSocket storage failed, trying WebTransport:', result.error);
+      } catch (err: any) {
+        console.warn('[ByteCave] WebSocket storage exception, trying WebTransport:', err.message);
+      }
+    } else {
+      console.log('[ByteCave] WebSocket relay not configured, trying WebTransport');
     }
 
-    console.log('[ByteCave] Storing via WebSocket relay');
+    // Fallback to WebTransport direct to node
+    console.log('[ByteCave] Attempting storage via WebTransport direct');
     
     try {
-      if (!this.storageWsClient) {
-        this.storageWsClient = new StorageWebSocketClient(this.config.relayWsUrl);
+      // Get nodes from relay discovery or contract discovery
+      let nodes: any[] = [];
+      
+      if (this.relayDiscovery) {
+        nodes = await this.relayDiscovery.getConnectedPeers();
+      } else if (this.contractDiscovery) {
+        nodes = await this.contractDiscovery.getActiveNodes();
       }
 
-      const wsAuth = authorization ? {
+      if (nodes.length === 0) {
+        return { 
+          success: false, 
+          error: 'No nodes available for WebTransport storage' 
+        };
+      }
+
+      const nodeWithWebTransport = nodes.find((node: any) => 
+        node.multiaddrs?.some((addr: string) => addr.includes('/webtransport'))
+      );
+
+      if (!nodeWithWebTransport || !nodeWithWebTransport.multiaddrs) {
+        return { 
+          success: false, 
+          error: 'No nodes with WebTransport support found' 
+        };
+      }
+
+      const wtMultiaddr = nodeWithWebTransport.multiaddrs.find((addr: string) => 
+        addr.includes('/webtransport')
+      );
+
+      if (!wtMultiaddr) {
+        return { 
+          success: false, 
+          error: 'No WebTransport multiaddr found' 
+        };
+      }
+
+      const wtClient = new StorageWebTransportClient(wtMultiaddr);
+      
+      const wtAuth = authorization ? {
         signature: authorization.signature,
         address: authorization.sender,
         timestamp: authorization.timestamp,
@@ -497,28 +577,27 @@ Nonce: ${nonce}`;
         contentHash: authorization.contentHash
       } : undefined;
 
-      const result = await this.storageWsClient.store({
+      const result = await wtClient.store({
         data: dataArray,
         contentType: mimeType || 'application/octet-stream',
         hashIdToken,
-        authorization: wsAuth,
-        timeout: 30000
+        authorization: wtAuth
       });
 
       if (result.success && result.cid) {
-        console.log('[ByteCave] ✓ WebSocket storage successful:', result.cid);
+        console.log('[ByteCave] ✓ WebTransport storage successful:', result.cid);
         return {
           success: true,
           cid: result.cid,
-          peerId: 'relay-ws'
+          peerId: nodeWithWebTransport.peerId
         };
       }
 
-      console.warn('[ByteCave] WebSocket storage failed:', result.error);
-      return { success: false, error: result.error || 'WebSocket storage failed' };
+      console.error('[ByteCave] WebTransport storage failed:', result.error);
+      return { success: false, error: result.error || 'All storage methods failed' };
     } catch (err: any) {
-      console.error('[ByteCave] WebSocket storage exception:', err.message);
-      return { success: false, error: err.message };
+      console.error('[ByteCave] WebTransport storage exception:', err.message);
+      return { success: false, error: `All storage methods failed: ${err.message}` };
     }
   }
 

package/src/storage-webtransport.ts

@@ -0,0 +1,156 @@
+/**
+ * WebTransport Storage Client
+ * 
+ * Provides direct browser-to-node storage over WebTransport (HTTP/3)
+ * Used as fallback when WebSocket relay is unavailable
+ */
+
+// Logger removed - using console.log for browser compatibility
+
+export interface WebTransportStorageRequest {
+  data: Uint8Array;
+  contentType: string;
+  hashIdToken?: number;
+  authorization?: {
+    signature: string;
+    address: string;
+    timestamp: number;
+    nonce: string;
+    appId: string;
+    contentHash: string;
+  };
+}
+
+export interface WebTransportStorageResponse {
+  success: boolean;
+  cid?: string;
+  error?: string;
+}
+
+export class StorageWebTransportClient {
+  private nodeMultiaddr: string;
+
+  constructor(nodeMultiaddr: string) {
+    this.nodeMultiaddr = nodeMultiaddr;
+  }
+
+  /**
+   * Store data via WebTransport direct to node
+   */
+  async store(request: WebTransportStorageRequest): Promise<WebTransportStorageResponse> {
+    try {
+      // Check if WebTransport is supported
+      if (typeof WebTransport === 'undefined') {
+        return {
+          success: false,
+          error: 'WebTransport not supported in this browser'
+        };
+      }
+
+      // Parse multiaddr to get WebTransport URL
+      // Format: /ip4/127.0.0.1/udp/4001/quic-v1/webtransport/certhash/...
+      const url = this.multiaddrToWebTransportUrl(this.nodeMultiaddr);
+      if (!url) {
+        return {
+          success: false,
+          error: 'Invalid WebTransport multiaddr'
+        };
+      }
+
+      console.log('[WebTransport] Connecting to node:', url);
+
+      // Create WebTransport connection
+      const transport = new WebTransport(url);
+      await transport.ready;
+
+      console.log('[WebTransport] Connected, opening bidirectional stream');
+
+      // Open bidirectional stream for storage protocol
+      const stream = await transport.createBidirectionalStream();
+      const writer = stream.writable.getWriter();
+      const reader = stream.readable.getReader();
+
+      // Send storage request
+      const requestData = {
+        type: 'storage-request',
+        data: Array.from(request.data), // Convert Uint8Array to array for JSON
+        contentType: request.contentType,
+        hashIdToken: request.hashIdToken,
+        authorization: request.authorization
+      };
+
+      const requestJson = JSON.stringify(requestData);
+      const requestBytes = new TextEncoder().encode(requestJson);
+      
+      await writer.write(requestBytes);
+      await writer.close();
+
+      console.log('[WebTransport] Request sent, waiting for response');
+
+      // Read response
+      const { value, done } = await reader.read();
+      if (done || !value) {
+        return {
+          success: false,
+          error: 'No response from node'
+        };
+      }
+
+      const responseJson = new TextDecoder().decode(value);
+      const response = JSON.parse(responseJson);
+
+      console.log('[WebTransport] Response received:', response);
+
+      // Close transport
+      await transport.close();
+
+      return response;
+
+    } catch (error: any) {
+      console.error('[WebTransport] Storage failed:', error);
+      return {
+        success: false,
+        error: error.message || 'WebTransport storage failed'
+      };
+    }
+  }
+
+  /**
+   * Convert libp2p multiaddr to WebTransport URL
+   */
+  private multiaddrToWebTransportUrl(multiaddr: string): string | null {
+    try {
+      // Parse multiaddr format: /ip4/127.0.0.1/udp/4001/quic-v1/webtransport
+      const parts = multiaddr.split('/').filter(p => p);
+      
+      let ip = '';
+      let port = '';
+      let hasQuic = false;
+      let hasWebTransport = false;
+
+      for (let i = 0; i < parts.length; i++) {
+        if (parts[i] === 'ip4' && i + 1 < parts.length) {
+          ip = parts[i + 1];
+        } else if (parts[i] === 'udp' && i + 1 < parts.length) {
+          port = parts[i + 1];
+        } else if (parts[i] === 'quic-v1') {
+          hasQuic = true;
+        } else if (parts[i] === 'webtransport') {
+          hasWebTransport = true;
+        }
+      }
+
+      if (!ip || !port || !hasQuic || !hasWebTransport) {
+        return null;
+      }
+
+      // WebTransport URL format: https://ip:port
+      // Note: In production, this needs proper certificate handling
+      return `https://${ip}:${port}`;
+
+    } catch (error) {
+      console.error('[WebTransport] Failed to parse multiaddr:', error);
+      return null;
+    }
+  }
+}