@gethashd/bytecave-browser 1.0.57 → 1.0.59

package/src/client.ts

@@ -7,7 +7,6 @@
 import { createLibp2p, Libp2p } 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';
@@ -22,7 +21,6 @@ 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, 
@@ -45,7 +43,6 @@ export class ByteCaveClient {
   private knownPeers: Map<string, PeerInfo> = new Map();
   private connectionState: ConnectionState = 'disconnected';
   private eventListeners: Map<string, Set<Function>> = new Map();
-  private readonly PEERS_CACHE_KEY = 'bytecave_known_peers';
 
   constructor(config: ByteCaveConfig) {
     this.config = {
@@ -64,9 +61,6 @@ export class ByteCaveClient {
     if (config.vaultNodeRegistryAddress && config.rpcUrl) {
       this.contractDiscovery = new ContractDiscovery(config.vaultNodeRegistryAddress, config.rpcUrl);
     }
-    
-    // Load cached peers from localStorage
-    this.loadCachedPeers();
   }
 
   /**
@@ -102,12 +96,11 @@ export class ByteCaveClient {
 
       console.log('[ByteCave] Bootstrap peers:', bootstrapPeers);
 
-      // Create libp2p node with WebRTC and WebTransport transports
+      // Create libp2p node with WebRTC transport
       this.node = await createLibp2p({
         transports: [
           webRTC() as any,
           webSockets() as any,
-          webTransport() as any,
           circuitRelayTransport() as any
         ],
         connectionEncrypters: [noise()],
@@ -283,19 +276,14 @@ export class ByteCaveClient {
                 // Fetch health data
                 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 as any).httpEndpoint || '',
-                    multiaddrs: peer.multiaddrs || [],
-                    relayAddrs: (peer as any).relayAddrs || [],
                     connected: true,
-                    isRegistered: (peer as any).isRegistered || false,
-                    onChainNodeId: (peer as any).onChainNodeId || ''
-                  };
-                  this.knownPeers.set(peer.peerId, peerInfo);
-                  this.saveCachedPeers();
+                    nodeId: health.nodeId
+                  });
+                  console.log('[ByteCave] ✓ Discovered peer:', health.nodeId || peer.peerId.slice(0, 12));
                 }
               } catch (err: any) {
                 console.warn('[ByteCave] Failed to process peer from directory:', peer.peerId.slice(0, 12), err.message);
@@ -336,11 +324,6 @@ export class ByteCaveClient {
         discoveredPeers: this.knownPeers.size
       });
 
-      // Dial cached peers after startup (important when relay is down)
-      setTimeout(() => {
-        this.dialCachedPeers();
-      }, 2000); // Wait 2s for node to fully initialize
-
     } catch (error) {
       this.setConnectionState('error');
       console.error('Failed to start ByteCave client:', error);
@@ -407,19 +390,14 @@ export class ByteCaveClient {
                 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 as any).httpEndpoint || '',
-                      multiaddrs: (peer as any).multiaddrs || [],
-                      relayAddrs: (peer as any).relayAddrs || [],
                       connected: true,
-                      isRegistered: (peer as any).isRegistered || false,
-                      onChainNodeId: (peer as any).onChainNodeId || ''
-                    };
-                    this.knownPeers.set(peer.peerId, peerInfo);
-                    this.saveCachedPeers();
+                      nodeId: health.nodeId
+                    });
+                    console.log('[ByteCave] Refresh: ✓ Updated peer info:', health.nodeId || peer.peerId.slice(0, 12));
                   }
                 } catch (err: any) {
                   console.warn('[ByteCave] Refresh: Failed to get health from peer:', peer.peerId.slice(0, 12), err.message);
@@ -498,103 +476,19 @@ Nonce: ${nonce}`;
       }
     }
 
-    // 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');
+    // Use WebSocket relay for storage (simpler connection management than direct P2P)
+    if (!this.config.relayWsUrl) {
+      return { success: false, error: 'WebSocket relay URL not configured' };
     }
 
-    // Fallback to WebTransport direct to node
-    console.log('[ByteCave] Attempting storage via WebTransport direct');
+    console.log('[ByteCave] Storing via WebSocket relay');
     
     try {
-      // Try cached peers first, then discovery services
-      let nodes: any[] = 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: 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' 
-        };
+      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,
@@ -603,27 +497,28 @@ Nonce: ${nonce}`;
         contentHash: authorization.contentHash
       } : undefined;
 
-      const result = await wtClient.store({
+      const result = await this.storageWsClient.store({
         data: dataArray,
         contentType: mimeType || 'application/octet-stream',
         hashIdToken,
-        authorization: wtAuth
+        authorization: wsAuth,
+        timeout: 30000
       });
 
       if (result.success && result.cid) {
-        console.log('[ByteCave] ✓ WebTransport storage successful:', result.cid);
+        console.log('[ByteCave] ✓ 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: any) {
-      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 };
     }
   }
 
@@ -818,59 +713,19 @@ Nonce: ${nonce}`;
     uptime: number;
   } | null> {
     try {
-      // Check if we have addresses for this peer
+      // Check if we have relay addresses for this peer
       const peerInfo = this.knownPeers.get(peerId);
       const relayAddrs = (peerInfo as any)?.relayAddrs;
-      const multiaddrs = peerInfo?.multiaddrs;
       
-      // Try to dial the peer if not already connected
-      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');
-          
-          // Try relay addresses first (if available)
-          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 as any);
-              console.log('[ByteCave] ✓ Connected via relay');
-            } catch (dialError: any) {
-              console.warn('[ByteCave] Relay dial failed:', dialError.message);
-              
-              // Fallback to WebTransport if relay fails
-              if (multiaddrs && multiaddrs.length > 0) {
-                const wtAddr = multiaddrs.find((addr: string) => 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 as any);
-                    console.log('[ByteCave] ✓ Connected via WebTransport');
-                  } catch (wtError: any) {
-                    console.warn('[ByteCave] WebTransport dial failed:', wtError.message);
-                  }
-                }
-              }
-            }
-          } else if (multiaddrs && multiaddrs.length > 0) {
-            // No relay addresses, try WebTransport directly
-            const wtAddr = multiaddrs.find((addr: string) => 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 as any);
-                console.log('[ByteCave] ✓ Connected via WebTransport');
-              } catch (wtError: any) {
-                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 we have relay addresses, dial through relay first
+      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 as any);
+          console.log('[ByteCave] Successfully dialed peer through relay');
+        } catch (dialError) {
+          console.warn('[ByteCave] Failed to dial through relay:', dialError);
         }
       }
       
@@ -1000,132 +855,11 @@ Nonce: ${nonce}`;
     };
 
     this.knownPeers.set(announcement.peerId, peerInfo);
-    this.saveCachedPeers();
-
-    // Attempt to dial the peer if not already connected
-    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
-   */
-  private async dialPeer(peerId: string, relayAddrs?: string[], multiaddrs?: string[]): Promise<void> {
-    if (!this.node) return;
-
-    // Check if already connected
-    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));
-
-    // Try relay first
-    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 as any);
-        console.log('[ByteCave] ✓ Connected via relay');
-        
-        // Update connected status
-        const peer = this.knownPeers.get(peerId);
-        if (peer) {
-          peer.connected = true;
-        }
-        return;
-      } catch (error: any) {
-        console.warn('[ByteCave] Relay dial failed:', error.message);
-      }
-    }
-
-    // Fallback to WebTransport
-    if (multiaddrs && multiaddrs.length > 0) {
-      const wtAddr = multiaddrs.find((addr: string) => 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 as any);
-          console.log('[ByteCave] ✓ Connected via WebTransport');
-          
-          // Update connected status
-          const peer = this.knownPeers.get(peerId);
-          if (peer) {
-            peer.connected = true;
-          }
-        } catch (error: any) {
-          console.warn('[ByteCave] WebTransport dial failed:', error.message);
-        }
-      }
-    }
-  }
   
 
-  /**
-   * Load cached peers from localStorage
-   */
-  private loadCachedPeers(): void {
-    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)
-   */
-  private async dialCachedPeers(): Promise<void> {
-    console.log('[ByteCave] Dialing', this.knownPeers.size, 'cached peers...');
-    
-    for (const [peerId, peerInfo] of this.knownPeers) {
-      // Skip if already connected
-      if (peerInfo.connected) {
-        continue;
-      }
-
-      const relayAddrs = (peerInfo as any).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);
-        });
-        
-        // Stagger dials to avoid overwhelming the network
-        await new Promise(resolve => setTimeout(resolve, 500));
-      }
-    }
-  }
-
-  /**
-   * Save known peers to localStorage
-   */
-  private saveCachedPeers(): void {
-    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/src/types.ts

@@ -25,10 +25,6 @@ export interface PeerInfo {
   nodeUrl?: string;
   isRegistered?: boolean;
   owner?: string;
-  multiaddrs?: string[];
-  httpEndpoint?: string;
-  relayAddrs?: string[];
-  onChainNodeId?: string;
 }
 
 export interface StoreResult {

package/dist/storage-webtransport.d.ts

@@ -1,47 +0,0 @@
-/**
- * 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;
-    /**
-     * Extract certificate hash from multiaddr
-     * Format: /ip4/127.0.0.1/udp/4001/quic-v1/webtransport/certhash/uEi...
-     */
-    private extractCertHash;
-    /**
-     * 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
-     */
-    private certHashToSHA256;
-}