@gethashd/bytecave-browser 1.0.58 → 1.0.60

package/dist/{chunk-NLZDUMYM.js → chunk-LMK44RJF.js}

@@ -5726,32 +5726,14 @@ var P2PProtocolClient = class {
         } catch (e) {
           console.warn("[ByteCave P2P] Could not get peer info from peerStore:", e);
         }
-        console.log("[ByteCave P2P] Step 2: Checking if connection upgrade needed...");
+        console.log("[ByteCave P2P] Step 2: Using existing connection...");
         if (existingConns.length === 0) {
           throw new Error("No connection to peer - cannot open protocol stream");
         }
-        let connection = existingConns[0];
+        const connection = existingConns[0];
         const isRelayCircuit = connection.remoteAddr.toString().includes("/p2p-circuit");
-        console.log("[ByteCave P2P] Connection type:", isRelayCircuit ? "relay circuit (limited)" : "direct");
+        console.log("[ByteCave P2P] Connection type:", isRelayCircuit ? "relay circuit" : "direct");
         console.log("[ByteCave P2P] Connection address:", connection.remoteAddr.toString());
-        if (isRelayCircuit) {
-          console.log("[ByteCave P2P] Waiting for DCUtR to upgrade relay circuit to direct WebRTC...");
-          const upgradeStart = Date.now();
-          const hasDirectConnection = await this.waitForDirectConnection(peerId, 5e3);
-          const upgradeDuration = Date.now() - upgradeStart;
-          if (!hasDirectConnection) {
-            console.error("[ByteCave P2P] DCUtR upgrade failed after", upgradeDuration, "ms");
-            throw new Error("Cannot use storage protocol - relay circuit upgrade to WebRTC failed");
-          }
-          console.log("[ByteCave P2P] DCUtR upgrade successful after", upgradeDuration, "ms");
-          const directConns = this.node.getConnections(peerIdObj);
-          const directConn = directConns.find((conn) => !conn.remoteAddr.toString().includes("/p2p-circuit"));
-          if (!directConn) {
-            throw new Error("DCUtR reported success but no direct connection found");
-          }
-          connection = directConn;
-          console.log("[ByteCave P2P] Using direct connection:", connection.remoteAddr.toString());
-        }
         console.log("[ByteCave P2P] Step 3: Opening protocol stream...");
         const streamStart = Date.now();
         let stream;
@@ -6057,7 +6039,6 @@ var p2pProtocolClient = new P2PProtocolClient();
 import { createLibp2p } from "libp2p";
 import { webRTC } from "@libp2p/webrtc";
 import { webSockets } from "@libp2p/websockets";
-import { webTransport } from "@libp2p/webtransport";
 import { noise } from "@chainsafe/libp2p-noise";
 import { yamux } from "@chainsafe/libp2p-yamux";
 import { floodsub } from "@libp2p/floodsub";
@@ -6227,136 +6208,6 @@ 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;
-      }
-      const host = ip === "127.0.0.1" ? "localhost" : ip;
-      return `https://${host}:${port}/storage`;
-    } catch (error) {
-      console.error("[WebTransport] Failed to parse multiaddr:", error);
-      return null;
-    }
-  }
-  /**
-   * Extract certificate hash from multiaddr
-   * Format: /ip4/127.0.0.1/udp/4001/quic-v1/webtransport/certhash/uEi...
-   */
-  extractCertHash(multiaddr2) {
-    try {
-      const parts = multiaddr2.split("/").filter((p) => p);
-      const certhashIndex = parts.indexOf("certhash");
-      if (certhashIndex !== -1 && certhashIndex + 1 < parts.length) {
-        return parts[certhashIndex + 1];
-      }
-      return null;
-    } catch (error) {
-      console.error("[WebTransport] Failed to extract cert hash:", error);
-      return null;
-    }
-  }
-  /**
-   * Convert libp2p multihash cert hash to SHA-256 ArrayBuffer for WebTransport
-   * The certhash in multiaddr format is: uEi<hex-hash>
-   * where 'u' = base32 multibase, 'Ei' = multihash prefix for SHA-256
-   */
-  async certHashToSHA256(multihash) {
-    try {
-      let hexHash = multihash.startsWith("uEi") ? multihash.slice(3) : multihash;
-      const bytes = new Uint8Array(hexHash.match(/.{1,2}/g).map((byte) => parseInt(byte, 16)));
-      console.log("[WebTransport] Decoded certificate hash:", hexHash);
-      console.log("[WebTransport] Hash bytes length:", bytes.length);
-      return bytes.buffer;
-    } catch (error) {
-      console.error("[WebTransport] Failed to convert cert hash:", error);
-      throw new Error("Failed to decode certificate hash");
-    }
-  }
-};
-
 // src/contracts/ContentRegistry.ts
 var CONTENT_REGISTRY_ABI = [
   "function registerContent(bytes32 cid, address owner, bytes32 appId, uint256 hashIdToken) external",
@@ -6373,7 +6224,6 @@ var ByteCaveClient = class {
     this.knownPeers = /* @__PURE__ */ new Map();
     this.connectionState = "disconnected";
     this.eventListeners = /* @__PURE__ */ new Map();
-    this.PEERS_CACHE_KEY = "bytecave_known_peers";
     this.config = {
       maxPeers: 10,
       connectionTimeout: 3e4,
@@ -6386,7 +6236,6 @@ var ByteCaveClient = class {
     if (config.vaultNodeRegistryAddress && config.rpcUrl) {
       this.contractDiscovery = new ContractDiscovery(config.vaultNodeRegistryAddress, config.rpcUrl);
     }
-    this.loadCachedPeers();
   }
   /**
    * Initialize and start the P2P client
@@ -6416,7 +6265,6 @@ var ByteCaveClient = class {
         transports: [
           webRTC(),
           webSockets(),
-          webTransport(),
           circuitRelayTransport()
         ],
         connectionEncrypters: [noise()],
@@ -6557,19 +6405,14 @@ var ByteCaveClient = class {
                 }
                 const health = await p2pProtocolClient.getHealthFromPeer(peer.peerId);
                 if (health) {
-                  const peerInfo = {
+                  this.knownPeers.set(peer.peerId, {
                     peerId: peer.peerId,
                     publicKey: health.publicKey || "",
                     contentTypes: health.contentTypes || "all",
-                    httpEndpoint: health.httpEndpoint || "",
-                    multiaddrs: peer.multiaddrs || [],
-                    relayAddrs: peer.relayAddrs || [],
                     connected: true,
-                    isRegistered: peer.isRegistered || false,
-                    onChainNodeId: peer.onChainNodeId || ""
-                  };
-                  this.knownPeers.set(peer.peerId, peerInfo);
-                  this.saveCachedPeers();
+                    nodeId: health.nodeId
+                  });
+                  console.log("[ByteCave] \u2713 Discovered peer:", health.nodeId || peer.peerId.slice(0, 12));
                 }
               } catch (err) {
                 console.warn("[ByteCave] Failed to process peer from directory:", peer.peerId.slice(0, 12), err.message);
@@ -6605,9 +6448,6 @@ var ByteCaveClient = class {
         connectedPeers: connectedPeers.length,
         discoveredPeers: this.knownPeers.size
       });
-      setTimeout(() => {
-        this.dialCachedPeers();
-      }, 2e3);
     } catch (error) {
       this.setConnectionState("error");
       console.error("Failed to start ByteCave client:", error);
@@ -6661,19 +6501,14 @@ var ByteCaveClient = class {
                 try {
                   const health = await p2pProtocolClient.getHealthFromPeer(peer.peerId);
                   if (health) {
-                    const peerInfo = {
+                    this.knownPeers.set(peer.peerId, {
                       peerId: peer.peerId,
                       publicKey: health.publicKey || "",
                       contentTypes: health.contentTypes || "all",
-                      httpEndpoint: health.httpEndpoint || "",
-                      multiaddrs: peer.multiaddrs || [],
-                      relayAddrs: peer.relayAddrs || [],
                       connected: true,
-                      isRegistered: peer.isRegistered || false,
-                      onChainNodeId: peer.onChainNodeId || ""
-                    };
-                    this.knownPeers.set(peer.peerId, peerInfo);
-                    this.saveCachedPeers();
+                      nodeId: health.nodeId
+                    });
+                    console.log("[ByteCave] Refresh: \u2713 Updated peer info:", health.nodeId || peer.peerId.slice(0, 12));
                   }
                 } catch (err) {
                   console.warn("[ByteCave] Refresh: Failed to get health from peer:", peer.peerId.slice(0, 12), err.message);
@@ -6738,81 +6573,15 @@ Nonce: ${nonce}`;
         console.warn("[ByteCave] Failed to create authorization:", err.message);
       }
     }
-    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");
+    if (!this.config.relayWsUrl) {
+      return { success: false, error: "WebSocket relay URL not configured" };
     }
-    console.log("[ByteCave] Attempting storage via WebTransport direct");
+    console.log("[ByteCave] Storing via WebSocket relay");
     try {
-      let nodes = Array.from(this.knownPeers.values());
-      if (nodes.length === 0) {
-        console.log("[ByteCave] No cached peers, trying discovery services");
-        if (this.relayDiscovery) {
-          nodes = await this.relayDiscovery.getConnectedPeers();
-        } else if (this.contractDiscovery) {
-          nodes = await this.contractDiscovery.getActiveNodes();
-        }
-      } else {
-        console.log("[ByteCave] Using", nodes.length, "cached peers for WebTransport");
-      }
-      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 wtMultiaddr = nodeWithWebTransport.multiaddrs.find(
-        (addr) => addr.includes("/webtransport")
-      );
-      if (!wtMultiaddr) {
-        return {
-          success: false,
-          error: "No WebTransport multiaddr found"
-        };
+      if (!this.storageWsClient) {
+        this.storageWsClient = new StorageWebSocketClient(this.config.relayWsUrl);
       }
-      const wtClient = new StorageWebTransportClient(wtMultiaddr);
-      const wtAuth = authorization ? {
+      const wsAuth = authorization ? {
         signature: authorization.signature,
         address: authorization.sender,
         timestamp: authorization.timestamp,
@@ -6820,25 +6589,26 @@ Nonce: ${nonce}`;
         appId: authorization.appId,
         contentHash: authorization.contentHash
       } : void 0;
-      const result = await wtClient.store({
+      const result = await this.storageWsClient.store({
         data: dataArray,
         contentType: mimeType || "application/octet-stream",
         hashIdToken,
-        authorization: wtAuth
+        authorization: wsAuth,
+        timeout: 3e4
       });
       if (result.success && result.cid) {
-        console.log("[ByteCave] \u2713 WebTransport storage successful:", result.cid);
+        console.log("[ByteCave] \u2713 WebSocket storage successful:", result.cid);
         return {
           success: true,
           cid: result.cid,
-          peerId: nodeWithWebTransport.peerId
+          peerId: "relay-ws"
         };
       }
-      console.error("[ByteCave] WebTransport storage failed:", result.error);
-      return { success: false, error: result.error || "All storage methods failed" };
+      console.warn("[ByteCave] WebSocket storage failed:", result.error);
+      return { success: false, error: result.error || "WebSocket storage failed" };
     } catch (err) {
-      console.error("[ByteCave] WebTransport storage exception:", err.message);
-      return { success: false, error: `All storage methods failed: ${err.message}` };
+      console.error("[ByteCave] WebSocket storage exception:", err.message);
+      return { success: false, error: err.message };
     }
   }
   /**
@@ -6990,48 +6760,14 @@ Nonce: ${nonce}`;
     try {
       const peerInfo = this.knownPeers.get(peerId);
       const relayAddrs = peerInfo?.relayAddrs;
-      const multiaddrs = peerInfo?.multiaddrs;
-      if (this.node) {
-        const connections = this.node.getConnections().filter((c) => c.remotePeer.toString() === peerId);
-        if (connections.length === 0) {
-          console.log("[ByteCave] No existing connection to peer, attempting to dial");
-          if (relayAddrs && relayAddrs.length > 0) {
-            console.log("[ByteCave] Trying relay address:", relayAddrs[0].slice(0, 60));
-            try {
-              const ma = multiaddr(relayAddrs[0]);
-              await this.node.dial(ma);
-              console.log("[ByteCave] \u2713 Connected via relay");
-            } catch (dialError) {
-              console.warn("[ByteCave] Relay dial failed:", dialError.message);
-              if (multiaddrs && multiaddrs.length > 0) {
-                const wtAddr = multiaddrs.find((addr) => addr.includes("/webtransport"));
-                if (wtAddr) {
-                  console.log("[ByteCave] Trying WebTransport address:", wtAddr.slice(0, 60));
-                  try {
-                    const ma = multiaddr(wtAddr);
-                    await this.node.dial(ma);
-                    console.log("[ByteCave] \u2713 Connected via WebTransport");
-                  } catch (wtError) {
-                    console.warn("[ByteCave] WebTransport dial failed:", wtError.message);
-                  }
-                }
-              }
-            }
-          } else if (multiaddrs && multiaddrs.length > 0) {
-            const wtAddr = multiaddrs.find((addr) => addr.includes("/webtransport"));
-            if (wtAddr) {
-              console.log("[ByteCave] Trying WebTransport address (no relay):", wtAddr.slice(0, 60));
-              try {
-                const ma = multiaddr(wtAddr);
-                await this.node.dial(ma);
-                console.log("[ByteCave] \u2713 Connected via WebTransport");
-              } catch (wtError) {
-                console.warn("[ByteCave] WebTransport dial failed:", wtError.message);
-              }
-            }
-          }
-        } else {
-          console.log("[ByteCave] Already connected to peer via", connections[0].remoteAddr.toString().slice(0, 60));
+      if (relayAddrs && relayAddrs.length > 0 && this.node) {
+        console.log("[ByteCave] Dialing peer through relay:", peerId.slice(0, 12), relayAddrs[0]);
+        try {
+          const ma = multiaddr(relayAddrs[0]);
+          await this.node.dial(ma);
+          console.log("[ByteCave] Successfully dialed peer through relay");
+        } catch (dialError) {
+          console.warn("[ByteCave] Failed to dial through relay:", dialError);
         }
       }
       const health = await p2pProtocolClient.getHealthFromPeer(peerId);
@@ -7137,106 +6873,8 @@ Nonce: ${nonce}`;
       onChainNodeId: announcement.onChainNodeId
     };
     this.knownPeers.set(announcement.peerId, peerInfo);
-    this.saveCachedPeers();
-    if (this.node && !peerInfo.connected) {
-      this.dialPeer(announcement.peerId, peerInfo.relayAddrs, peerInfo.multiaddrs).catch((err) => {
-        console.warn("[ByteCave] Failed to dial announced peer:", err.message);
-      });
-    }
     this.emit("peerAnnounce", peerInfo);
   }
-  /**
-   * Attempt to dial a peer using relay or WebTransport addresses
-   */
-  async dialPeer(peerId, relayAddrs, multiaddrs) {
-    if (!this.node) return;
-    const connections = this.node.getConnections().filter((c) => c.remotePeer.toString() === peerId);
-    if (connections.length > 0) {
-      console.log("[ByteCave] Already connected to peer:", peerId.slice(0, 12));
-      return;
-    }
-    console.log("[ByteCave] Attempting to dial peer:", peerId.slice(0, 12));
-    if (relayAddrs && relayAddrs.length > 0) {
-      console.log("[ByteCave] Trying relay address:", relayAddrs[0].slice(0, 60));
-      try {
-        const ma = multiaddr(relayAddrs[0]);
-        await this.node.dial(ma);
-        console.log("[ByteCave] \u2713 Connected via relay");
-        const peer = this.knownPeers.get(peerId);
-        if (peer) {
-          peer.connected = true;
-        }
-        return;
-      } catch (error) {
-        console.warn("[ByteCave] Relay dial failed:", error.message);
-      }
-    }
-    if (multiaddrs && multiaddrs.length > 0) {
-      const wtAddr = multiaddrs.find((addr) => addr.includes("/webtransport"));
-      if (wtAddr) {
-        console.log("[ByteCave] Trying WebTransport address:", wtAddr.slice(0, 60));
-        try {
-          const ma = multiaddr(wtAddr);
-          await this.node.dial(ma);
-          console.log("[ByteCave] \u2713 Connected via WebTransport");
-          const peer = this.knownPeers.get(peerId);
-          if (peer) {
-            peer.connected = true;
-          }
-        } catch (error) {
-          console.warn("[ByteCave] WebTransport dial failed:", error.message);
-        }
-      }
-    }
-  }
-  /**
-   * Load cached peers from localStorage
-   */
-  loadCachedPeers() {
-    try {
-      const cached = localStorage.getItem(this.PEERS_CACHE_KEY);
-      if (cached) {
-        const peers = JSON.parse(cached);
-        console.log("[ByteCave] Loaded", peers.length, "cached peers from localStorage");
-        for (const peer of peers) {
-          this.knownPeers.set(peer.peerId, { ...peer, connected: false });
-        }
-      }
-    } catch (error) {
-      console.warn("[ByteCave] Failed to load cached peers:", error);
-    }
-  }
-  /**
-   * Dial all cached peers (used on startup when relay might be down)
-   */
-  async dialCachedPeers() {
-    console.log("[ByteCave] Dialing", this.knownPeers.size, "cached peers...");
-    for (const [peerId, peerInfo] of this.knownPeers) {
-      if (peerInfo.connected) {
-        continue;
-      }
-      const relayAddrs = peerInfo.relayAddrs;
-      const multiaddrs = peerInfo.multiaddrs;
-      if (relayAddrs || multiaddrs) {
-        this.dialPeer(peerId, relayAddrs, multiaddrs).catch((err) => {
-          console.warn("[ByteCave] Failed to dial cached peer:", peerId.slice(0, 12), err.message);
-        });
-        await new Promise((resolve) => setTimeout(resolve, 500));
-      }
-    }
-  }
-  /**
-   * Save known peers to localStorage
-   */
-  saveCachedPeers() {
-    try {
-      const peers = Array.from(this.knownPeers.values());
-      localStorage.setItem(this.PEERS_CACHE_KEY, JSON.stringify(peers));
-      console.log("[ByteCave] Saved", peers.length, "peers to localStorage");
-    } catch (error) {
-      console.warn("[ByteCave] Failed to save cached peers:", error);
-    }
-  }
   /**
    * Check if a nodeId is registered in the on-chain registry
    */

package/dist/client.d.ts

@@ -14,7 +14,6 @@ export declare class ByteCaveClient {
     private knownPeers;
     private connectionState;
     private eventListeners;
-    private readonly PEERS_CACHE_KEY;
     constructor(config: ByteCaveConfig);
     /**
      * Initialize and start the P2P client
@@ -98,22 +97,6 @@ export declare class ByteCaveClient {
     private setupEventListeners;
     private setupPubsub;
     private handlePeerAnnouncement;
-    /**
-     * Attempt to dial a peer using relay or WebTransport addresses
-     */
-    private dialPeer;
-    /**
-     * Load cached peers from localStorage
-     */
-    private loadCachedPeers;
-    /**
-     * Dial all cached peers (used on startup when relay might be down)
-     */
-    private dialCachedPeers;
-    /**
-     * Save known peers to localStorage
-     */
-    private saveCachedPeers;
     /**
      * Check if a nodeId is registered in the on-chain registry
      */