@gethashd/bytecave-browser 1.0.1 → 1.0.3

package/dist/{chunk-OJEETLZQ.js → chunk-O56JMOMV.js}

@@ -6,6 +6,29 @@ import {
 
 // src/discovery.ts
 import { ethers } from "ethers";
+var RelayDiscovery = class {
+  constructor(relayHttpUrl) {
+    this.relayHttpUrl = relayHttpUrl;
+  }
+  /**
+   * Get currently connected storage nodes from relay
+   * Returns peer IDs and relay circuit multiaddrs
+   */
+  async getConnectedPeers() {
+    try {
+      const response = await fetch(`${this.relayHttpUrl}/peers`);
+      if (!response.ok) {
+        throw new Error(`Relay returned ${response.status}`);
+      }
+      const peers = await response.json();
+      console.log("[RelayDiscovery] Found connected peers:", peers.length);
+      return peers;
+    } catch (error) {
+      console.warn("[RelayDiscovery] Failed to fetch peers from relay:", error);
+      return [];
+    }
+  }
+};
 var VAULT_REGISTRY_ABI = [
   "function getActiveNodes() external view returns (bytes32[] memory)",
   "function getNode(bytes32 nodeId) external view returns (tuple(address owner, bytes publicKey, string url, bytes32 metadataHash, uint256 registeredAt, bool active))",
@@ -5956,8 +5979,13 @@ var ByteCaveClient = class {
       connectionTimeout: 3e4,
       ...config
     };
+    if (config.relayPeers && config.relayPeers.length > 0) {
+      const relayHttpUrl = config.relayPeers[0];
+      this.relayDiscovery = new RelayDiscovery(relayHttpUrl);
+      console.log("[ByteCave] Using relay HTTP URL for peer discovery:", relayHttpUrl);
+    }
     if (config.vaultNodeRegistryAddress && config.rpcUrl) {
-      this.discovery = new ContractDiscovery(config.vaultNodeRegistryAddress, config.rpcUrl);
+      this.contractDiscovery = new ContractDiscovery(config.vaultNodeRegistryAddress, config.rpcUrl);
     }
   }
   /**
@@ -5976,12 +6004,8 @@ var ByteCaveClient = class {
         console.log("[ByteCave] Using direct node addresses:", this.config.directNodeAddrs);
         bootstrapPeers.push(...this.config.directNodeAddrs);
       }
-      if (this.config.relayPeers && this.config.relayPeers.length > 0) {
-        console.log("[ByteCave] Using relay peers as fallback:", this.config.relayPeers);
-        bootstrapPeers.push(...this.config.relayPeers);
-      }
       if (bootstrapPeers.length === 0) {
-        console.warn("[ByteCave] No peers configured - will rely on contract discovery only");
+        console.warn("[ByteCave] No direct node addresses configured - will rely on relay peer discovery");
       }
       console.log("[ByteCave] Bootstrap peers:", bootstrapPeers);
       this.node = await createLibp2p({
@@ -6029,7 +6053,50 @@ var ByteCaveClient = class {
       const connectedPeers = this.node.getPeers();
       console.log("[ByteCave] Connected peers after relay dial:", connectedPeers.length, connectedPeers.map((p) => p.toString()));
       p2pProtocolClient.setNode(this.node);
-      console.log("[ByteCave] Querying relay for peer directory...");
+      if (this.relayDiscovery) {
+        console.log("[ByteCave] Querying relay HTTP endpoint for instant peer list...");
+        try {
+          const relayPeers = await this.relayDiscovery.getConnectedPeers();
+          if (relayPeers.length > 0) {
+            console.log("[ByteCave] Got", relayPeers.length, "peers from relay HTTP endpoint");
+            for (const peer of relayPeers) {
+              try {
+                console.log("[ByteCave] Dialing peer:", peer.peerId.slice(0, 12) + "...");
+                let connected = false;
+                for (const addr of peer.multiaddrs) {
+                  try {
+                    const ma = multiaddr(addr);
+                    await this.node.dial(ma);
+                    connected = true;
+                    console.log("[ByteCave] \u2713 Connected via relay circuit");
+                    break;
+                  } catch (dialErr) {
+                    console.warn("[ByteCave] Failed to dial:", dialErr.message);
+                  }
+                }
+                if (connected) {
+                  const health = await p2pProtocolClient.getHealthFromPeer(peer.peerId);
+                  if (health) {
+                    this.knownPeers.set(peer.peerId, {
+                      peerId: peer.peerId,
+                      publicKey: health.publicKey || "",
+                      contentTypes: health.contentTypes || "all",
+                      connected: true,
+                      nodeId: health.nodeId
+                    });
+                    console.log("[ByteCave] \u2713 Discovered peer via HTTP relay:", health.nodeId || peer.peerId.slice(0, 12));
+                  }
+                }
+              } catch (err) {
+                console.warn("[ByteCave] Failed to process peer from HTTP relay:", err.message);
+              }
+            }
+          }
+        } catch (err) {
+          console.warn("[ByteCave] HTTP relay discovery failed, falling back to P2P directory:", err.message);
+        }
+      }
+      console.log("[ByteCave] Querying relay for peer directory via P2P...");
       for (const relayAddr of bootstrapPeers) {
         try {
           const parts = relayAddr.split("/p2p/");
@@ -6112,20 +6179,13 @@ var ByteCaveClient = class {
       console.warn("[ByteCave] Cannot refresh - node not initialized");
       return;
     }
-    const bootstrapPeers = [
-      ...this.config.directNodeAddrs || [],
-      ...this.config.relayPeers || []
-    ];
-    console.log("[ByteCave] Refreshing peer directory from relays...");
-    for (const relayAddr of bootstrapPeers) {
+    console.log("[ByteCave] Refreshing peer directory from relay HTTP endpoint...");
+    if (this.relayDiscovery) {
       try {
-        const parts = relayAddr.split("/p2p/");
-        if (parts.length < 2) continue;
-        const relayPeerId = parts[parts.length - 1];
-        const directory = await p2pProtocolClient.getPeerDirectoryFromRelay(relayPeerId);
-        if (directory && directory.peers.length > 0) {
-          console.log("[ByteCave] Refresh: Got", directory.peers.length, "peers from relay directory");
-          for (const peer of directory.peers) {
+        const relayPeers = await this.relayDiscovery.getConnectedPeers();
+        if (relayPeers.length > 0) {
+          console.log("[ByteCave] Refresh: Got", relayPeers.length, "peers from relay HTTP endpoint");
+          for (const peer of relayPeers) {
             const isConnected = this.node.getPeers().some((p) => p.toString() === peer.peerId);
             const knownPeer = this.knownPeers.get(peer.peerId);
             if (!isConnected || !knownPeer) {
@@ -6163,7 +6223,6 @@ var ByteCaveClient = class {
               console.debug("[ByteCave] Refresh: Peer already connected:", peer.peerId.slice(0, 12) + "...");
             }
           }
-          break;
         }
       } catch (err) {
         console.warn("[ByteCave] Refresh: Failed to get directory from relay:", err.message);
@@ -6184,10 +6243,7 @@ var ByteCaveClient = class {
       return { success: false, error: "P2P node not initialized" };
     }
     const allPeers = this.node.getPeers();
-    const relayPeerIds = new Set(
-      this.config.relayPeers?.map((addr) => addr.split("/p2p/").pop()) || []
-    );
-    const connectedPeerIds = allPeers.map((p) => p.toString()).filter((peerId) => !relayPeerIds.has(peerId));
+    const connectedPeerIds = allPeers.map((p) => p.toString());
     console.log("[ByteCave] Store - connected storage peers:", connectedPeerIds.length);
     console.log("[ByteCave] Store - knownPeers with registration info:", this.knownPeers.size);
     if (connectedPeerIds.length === 0) {
@@ -6550,11 +6606,11 @@ Nonce: ${nonce}`;
    * Check if a nodeId is registered in the on-chain registry
    */
   async checkNodeRegistration(nodeId) {
-    if (!this.discovery) {
+    if (!this.contractDiscovery) {
       return true;
     }
     try {
-      const registeredNodes = await this.discovery.getActiveNodes();
+      const registeredNodes = await this.contractDiscovery.getActiveNodes();
       return registeredNodes.some((node) => node.nodeId === nodeId);
     } catch (error) {
       console.warn("[ByteCave] Failed to check node registration:", error);
@@ -7058,6 +7114,7 @@ function useHashdUrl(hashdUrl) {
 }
 
 export {
+  RelayDiscovery,
   ContractDiscovery,
   p2pProtocolClient,
   ByteCaveClient,

package/dist/client.d.ts

@@ -7,7 +7,8 @@ import { ethers } from 'ethers';
 import type { ByteCaveConfig, PeerInfo, StoreResult, RetrieveResult, ConnectionState, SignalingMessage } from './types.js';
 export declare class ByteCaveClient {
     private node;
-    private discovery?;
+    private contractDiscovery?;
+    private relayDiscovery?;
     private config;
     private knownPeers;
     private connectionState;

package/dist/discovery.d.ts

@@ -1,10 +1,27 @@
 /**
- * Contract-based peer discovery
+ * Peer discovery for ByteCave browser clients
  *
- * Reads registered nodes from the VaultNodeRegistry smart contract
- * to bootstrap P2P connections without any central server.
+ * Supports two discovery methods:
+ * 1. RelayDiscovery - Fast: Query relay's /peers endpoint for instant peer list
+ * 2. ContractDiscovery - Slow: Read from VaultNodeRegistry smart contract
  */
 import type { NodeRegistryEntry } from './types.js';
+/**
+ * Relay-based peer discovery (FAST)
+ * Queries the relay's HTTP endpoint for currently connected storage nodes
+ */
+export declare class RelayDiscovery {
+    private relayHttpUrl;
+    constructor(relayHttpUrl: string);
+    /**
+     * Get currently connected storage nodes from relay
+     * Returns peer IDs and relay circuit multiaddrs
+     */
+    getConnectedPeers(): Promise<Array<{
+        peerId: string;
+        multiaddrs: string[];
+    }>>;
+}
 export declare class ContractDiscovery {
     private provider;
     private contract;

package/dist/index.cjs

@@ -38,6 +38,7 @@ __export(src_exports, {
   HashdAudio: () => HashdAudio,
   HashdImage: () => HashdImage,
   HashdVideo: () => HashdVideo,
+  RelayDiscovery: () => RelayDiscovery,
   TEST_EXPORT: () => TEST_EXPORT,
   clearHashdCache: () => clearHashdCache,
   createHashdUrl: () => createHashdUrl,
@@ -72,6 +73,29 @@ var import_ethers2 = require("ethers");
 
 // src/discovery.ts
 var import_ethers = require("ethers");
+var RelayDiscovery = class {
+  constructor(relayHttpUrl) {
+    this.relayHttpUrl = relayHttpUrl;
+  }
+  /**
+   * Get currently connected storage nodes from relay
+   * Returns peer IDs and relay circuit multiaddrs
+   */
+  async getConnectedPeers() {
+    try {
+      const response = await fetch(`${this.relayHttpUrl}/peers`);
+      if (!response.ok) {
+        throw new Error(`Relay returned ${response.status}`);
+      }
+      const peers = await response.json();
+      console.log("[RelayDiscovery] Found connected peers:", peers.length);
+      return peers;
+    } catch (error) {
+      console.warn("[RelayDiscovery] Failed to fetch peers from relay:", error);
+      return [];
+    }
+  }
+};
 var VAULT_REGISTRY_ABI = [
   "function getActiveNodes() external view returns (bytes32[] memory)",
   "function getNode(bytes32 nodeId) external view returns (tuple(address owner, bytes publicKey, string url, bytes32 metadataHash, uint256 registeredAt, bool active))",
@@ -6008,8 +6032,13 @@ var ByteCaveClient = class {
       connectionTimeout: 3e4,
       ...config
     };
+    if (config.relayPeers && config.relayPeers.length > 0) {
+      const relayHttpUrl = config.relayPeers[0];
+      this.relayDiscovery = new RelayDiscovery(relayHttpUrl);
+      console.log("[ByteCave] Using relay HTTP URL for peer discovery:", relayHttpUrl);
+    }
     if (config.vaultNodeRegistryAddress && config.rpcUrl) {
-      this.discovery = new ContractDiscovery(config.vaultNodeRegistryAddress, config.rpcUrl);
+      this.contractDiscovery = new ContractDiscovery(config.vaultNodeRegistryAddress, config.rpcUrl);
     }
   }
   /**
@@ -6028,12 +6057,8 @@ var ByteCaveClient = class {
         console.log("[ByteCave] Using direct node addresses:", this.config.directNodeAddrs);
         bootstrapPeers.push(...this.config.directNodeAddrs);
       }
-      if (this.config.relayPeers && this.config.relayPeers.length > 0) {
-        console.log("[ByteCave] Using relay peers as fallback:", this.config.relayPeers);
-        bootstrapPeers.push(...this.config.relayPeers);
-      }
       if (bootstrapPeers.length === 0) {
-        console.warn("[ByteCave] No peers configured - will rely on contract discovery only");
+        console.warn("[ByteCave] No direct node addresses configured - will rely on relay peer discovery");
       }
       console.log("[ByteCave] Bootstrap peers:", bootstrapPeers);
       this.node = await (0, import_libp2p.createLibp2p)({
@@ -6081,7 +6106,50 @@ var ByteCaveClient = class {
       const connectedPeers = this.node.getPeers();
       console.log("[ByteCave] Connected peers after relay dial:", connectedPeers.length, connectedPeers.map((p) => p.toString()));
       p2pProtocolClient.setNode(this.node);
-      console.log("[ByteCave] Querying relay for peer directory...");
+      if (this.relayDiscovery) {
+        console.log("[ByteCave] Querying relay HTTP endpoint for instant peer list...");
+        try {
+          const relayPeers = await this.relayDiscovery.getConnectedPeers();
+          if (relayPeers.length > 0) {
+            console.log("[ByteCave] Got", relayPeers.length, "peers from relay HTTP endpoint");
+            for (const peer of relayPeers) {
+              try {
+                console.log("[ByteCave] Dialing peer:", peer.peerId.slice(0, 12) + "...");
+                let connected = false;
+                for (const addr of peer.multiaddrs) {
+                  try {
+                    const ma = (0, import_multiaddr.multiaddr)(addr);
+                    await this.node.dial(ma);
+                    connected = true;
+                    console.log("[ByteCave] \u2713 Connected via relay circuit");
+                    break;
+                  } catch (dialErr) {
+                    console.warn("[ByteCave] Failed to dial:", dialErr.message);
+                  }
+                }
+                if (connected) {
+                  const health = await p2pProtocolClient.getHealthFromPeer(peer.peerId);
+                  if (health) {
+                    this.knownPeers.set(peer.peerId, {
+                      peerId: peer.peerId,
+                      publicKey: health.publicKey || "",
+                      contentTypes: health.contentTypes || "all",
+                      connected: true,
+                      nodeId: health.nodeId
+                    });
+                    console.log("[ByteCave] \u2713 Discovered peer via HTTP relay:", health.nodeId || peer.peerId.slice(0, 12));
+                  }
+                }
+              } catch (err) {
+                console.warn("[ByteCave] Failed to process peer from HTTP relay:", err.message);
+              }
+            }
+          }
+        } catch (err) {
+          console.warn("[ByteCave] HTTP relay discovery failed, falling back to P2P directory:", err.message);
+        }
+      }
+      console.log("[ByteCave] Querying relay for peer directory via P2P...");
       for (const relayAddr of bootstrapPeers) {
         try {
           const parts = relayAddr.split("/p2p/");
@@ -6164,20 +6232,13 @@ var ByteCaveClient = class {
       console.warn("[ByteCave] Cannot refresh - node not initialized");
       return;
     }
-    const bootstrapPeers = [
-      ...this.config.directNodeAddrs || [],
-      ...this.config.relayPeers || []
-    ];
-    console.log("[ByteCave] Refreshing peer directory from relays...");
-    for (const relayAddr of bootstrapPeers) {
+    console.log("[ByteCave] Refreshing peer directory from relay HTTP endpoint...");
+    if (this.relayDiscovery) {
       try {
-        const parts = relayAddr.split("/p2p/");
-        if (parts.length < 2) continue;
-        const relayPeerId = parts[parts.length - 1];
-        const directory = await p2pProtocolClient.getPeerDirectoryFromRelay(relayPeerId);
-        if (directory && directory.peers.length > 0) {
-          console.log("[ByteCave] Refresh: Got", directory.peers.length, "peers from relay directory");
-          for (const peer of directory.peers) {
+        const relayPeers = await this.relayDiscovery.getConnectedPeers();
+        if (relayPeers.length > 0) {
+          console.log("[ByteCave] Refresh: Got", relayPeers.length, "peers from relay HTTP endpoint");
+          for (const peer of relayPeers) {
             const isConnected = this.node.getPeers().some((p) => p.toString() === peer.peerId);
             const knownPeer = this.knownPeers.get(peer.peerId);
             if (!isConnected || !knownPeer) {
@@ -6215,7 +6276,6 @@ var ByteCaveClient = class {
               console.debug("[ByteCave] Refresh: Peer already connected:", peer.peerId.slice(0, 12) + "...");
             }
           }
-          break;
         }
       } catch (err) {
         console.warn("[ByteCave] Refresh: Failed to get directory from relay:", err.message);
@@ -6236,10 +6296,7 @@ var ByteCaveClient = class {
       return { success: false, error: "P2P node not initialized" };
     }
     const allPeers = this.node.getPeers();
-    const relayPeerIds = new Set(
-      this.config.relayPeers?.map((addr) => addr.split("/p2p/").pop()) || []
-    );
-    const connectedPeerIds = allPeers.map((p) => p.toString()).filter((peerId) => !relayPeerIds.has(peerId));
+    const connectedPeerIds = allPeers.map((p) => p.toString());
     console.log("[ByteCave] Store - connected storage peers:", connectedPeerIds.length);
     console.log("[ByteCave] Store - knownPeers with registration info:", this.knownPeers.size);
     if (connectedPeerIds.length === 0) {
@@ -6602,11 +6659,11 @@ Nonce: ${nonce}`;
    * Check if a nodeId is registered in the on-chain registry
    */
   async checkNodeRegistration(nodeId) {
-    if (!this.discovery) {
+    if (!this.contractDiscovery) {
       return true;
     }
     try {
-      const registeredNodes = await this.discovery.getActiveNodes();
+      const registeredNodes = await this.contractDiscovery.getActiveNodes();
       return registeredNodes.some((node) => node.nodeId === nodeId);
     } catch (error) {
       console.warn("[ByteCave] Failed to check node registration:", error);
@@ -7261,6 +7318,7 @@ var TEST_EXPORT = "ByteCave Browser Package v1.0.0";
   HashdAudio,
   HashdImage,
   HashdVideo,
+  RelayDiscovery,
   TEST_EXPORT,
   clearHashdCache,
   createHashdUrl,

package/dist/index.d.ts

@@ -6,7 +6,7 @@
  */
 export declare const TEST_EXPORT = "ByteCave Browser Package v1.0.0";
 export { ByteCaveClient } from './client.js';
-export { ContractDiscovery } from './discovery.js';
+export { ContractDiscovery, RelayDiscovery } from './discovery.js';
 export { p2pProtocolClient } from './p2p-protocols.js';
 export { ByteCaveProvider, useByteCaveContext } from './provider.js';
 export type { P2PHealthResponse, P2PInfoResponse } from './p2p-protocols.js';

package/dist/index.js

@@ -5,6 +5,7 @@ import {
   HashdAudio,
   HashdImage,
   HashdVideo,
+  RelayDiscovery,
   p2pProtocolClient,
   useByteCaveContext,
   useHashdBatch,
@@ -12,7 +13,7 @@ import {
   useHashdImage,
   useHashdMedia,
   useHashdUrl
-} from "./chunk-OJEETLZQ.js";
+} from "./chunk-O56JMOMV.js";
 import {
   clearHashdCache,
   createHashdUrl,
@@ -32,6 +33,7 @@ export {
   HashdAudio,
   HashdImage,
   HashdVideo,
+  RelayDiscovery,
   TEST_EXPORT,
   clearHashdCache,
   createHashdUrl,

package/dist/react/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gethashd/bytecave-browser",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "ByteCave browser client for WebRTC P2P connections to storage nodes",
   "main": "dist/index.cjs",
   "module": "dist/index.js",

package/src/client.ts

@@ -17,7 +17,7 @@ import { multiaddr } from '@multiformats/multiaddr';
 import { peerIdFromString } from '@libp2p/peer-id';
 import { fromString, toString } from 'uint8arrays';
 import { ethers } from 'ethers';
-import { ContractDiscovery } from './discovery.js';
+import { ContractDiscovery, RelayDiscovery } from './discovery.js';
 import { p2pProtocolClient } from './p2p-protocols.js';
 import { CONTENT_REGISTRY_ABI } from './contracts/ContentRegistry.js';
 import type { 
@@ -34,7 +34,8 @@ const SIGNALING_TOPIC_PREFIX = 'bytecave-signaling-';
 
 export class ByteCaveClient {
   private node: Libp2p | null = null;
-  private discovery?: ContractDiscovery; // Optional - only if contract address provided
+  private contractDiscovery?: ContractDiscovery; // Optional - only if contract address provided
+  private relayDiscovery?: RelayDiscovery; // Optional - for fast peer discovery via relay
   private config: ByteCaveConfig;
   private knownPeers: Map<string, PeerInfo> = new Map();
   private connectionState: ConnectionState = 'disconnected';
@@ -46,9 +47,18 @@ export class ByteCaveClient {
       connectionTimeout: 30000,
       ...config
     };
-    // Only initialize contract discovery if contract address is provided
+    
+    // Initialize relay discovery using HTTP URLs from relayPeers
+    if (config.relayPeers && config.relayPeers.length > 0) {
+      // Use first relay HTTP URL for peer discovery
+      const relayHttpUrl = config.relayPeers[0];
+      this.relayDiscovery = new RelayDiscovery(relayHttpUrl);
+      console.log('[ByteCave] Using relay HTTP URL for peer discovery:', relayHttpUrl);
+    }
+    
+    // Initialize contract discovery if contract address is provided
     if (config.vaultNodeRegistryAddress && config.rpcUrl) {
-      this.discovery = new ContractDiscovery(config.vaultNodeRegistryAddress, config.rpcUrl);
+      this.contractDiscovery = new ContractDiscovery(config.vaultNodeRegistryAddress, config.rpcUrl);
     }
   }
 
@@ -73,14 +83,8 @@ export class ByteCaveClient {
         bootstrapPeers.push(...this.config.directNodeAddrs);
       }
 
-      // Use relay peers for fallback (circuit relay connections)
-      if (this.config.relayPeers && this.config.relayPeers.length > 0) {
-        console.log('[ByteCave] Using relay peers as fallback:', this.config.relayPeers);
-        bootstrapPeers.push(...this.config.relayPeers);
-      }
-
       if (bootstrapPeers.length === 0) {
-        console.warn('[ByteCave] No peers configured - will rely on contract discovery only');
+        console.warn('[ByteCave] No direct node addresses configured - will rely on relay peer discovery');
       }
 
       console.log('[ByteCave] Bootstrap peers:', bootstrapPeers);
@@ -144,8 +148,58 @@ export class ByteCaveClient {
       // Initialize P2P protocol client with the libp2p node
       p2pProtocolClient.setNode(this.node);
 
-      // Fast discovery: Query relay for peer directory
-      console.log('[ByteCave] Querying relay for peer directory...');
+      // FASTEST discovery: Query relay HTTP endpoint for connected peers
+      if (this.relayDiscovery) {
+        console.log('[ByteCave] Querying relay HTTP endpoint for instant peer list...');
+        try {
+          const relayPeers = await this.relayDiscovery.getConnectedPeers();
+          if (relayPeers.length > 0) {
+            console.log('[ByteCave] Got', relayPeers.length, 'peers from relay HTTP endpoint');
+            
+            // Dial each peer using their relay circuit multiaddrs
+            for (const peer of relayPeers) {
+              try {
+                console.log('[ByteCave] Dialing peer:', peer.peerId.slice(0, 12) + '...');
+                
+                let connected = false;
+                for (const addr of peer.multiaddrs) {
+                  try {
+                    const ma = multiaddr(addr);
+                    await this.node.dial(ma as any);
+                    connected = true;
+                    console.log('[ByteCave] ✓ Connected via relay circuit');
+                    break;
+                  } catch (dialErr: any) {
+                    console.warn('[ByteCave] Failed to dial:', dialErr.message);
+                  }
+                }
+                
+                if (connected) {
+                  // Fetch health data
+                  const health = await p2pProtocolClient.getHealthFromPeer(peer.peerId);
+                  if (health) {
+                    this.knownPeers.set(peer.peerId, {
+                      peerId: peer.peerId,
+                      publicKey: health.publicKey || '',
+                      contentTypes: health.contentTypes || 'all',
+                      connected: true,
+                      nodeId: health.nodeId
+                    });
+                    console.log('[ByteCave] ✓ Discovered peer via HTTP relay:', health.nodeId || peer.peerId.slice(0, 12));
+                  }
+                }
+              } catch (err: any) {
+                console.warn('[ByteCave] Failed to process peer from HTTP relay:', err.message);
+              }
+            }
+          }
+        } catch (err: any) {
+          console.warn('[ByteCave] HTTP relay discovery failed, falling back to P2P directory:', err.message);
+        }
+      }
+
+      // Fallback: Query relay for peer directory via P2P protocol
+      console.log('[ByteCave] Querying relay for peer directory via P2P...');
       for (const relayAddr of bootstrapPeers) {
         try {
           // Extract relay peer ID from multiaddr
@@ -244,33 +298,24 @@ export class ByteCaveClient {
       return;
     }
 
-    const bootstrapPeers = [
-      ...(this.config.directNodeAddrs || []),
-      ...(this.config.relayPeers || [])
-    ];
-
-    console.log('[ByteCave] Refreshing peer directory from relays...');
+    console.log('[ByteCave] Refreshing peer directory from relay HTTP endpoint...');
     
-    for (const relayAddr of bootstrapPeers) {
+    // Use HTTP relay discovery for instant refresh
+    if (this.relayDiscovery) {
       try {
-        // Extract relay peer ID from multiaddr
-        const parts = relayAddr.split('/p2p/');
-        if (parts.length < 2) continue;
-        const relayPeerId = parts[parts.length - 1];
-        
-        const directory = await p2pProtocolClient.getPeerDirectoryFromRelay(relayPeerId);
-        if (directory && directory.peers.length > 0) {
-          console.log('[ByteCave] Refresh: Got', directory.peers.length, 'peers from relay directory');
+        const relayPeers = await this.relayDiscovery.getConnectedPeers();
+        if (relayPeers.length > 0) {
+          console.log('[ByteCave] Refresh: Got', relayPeers.length, 'peers from relay HTTP endpoint');
           
           // Check each peer and reconnect if disconnected
-          for (const peer of directory.peers) {
+          for (const peer of relayPeers) {
             const isConnected = this.node.getPeers().some(p => p.toString() === peer.peerId);
             const knownPeer = this.knownPeers.get(peer.peerId);
             
             if (!isConnected || !knownPeer) {
               console.log('[ByteCave] Refresh: Reconnecting to peer:', peer.peerId.slice(0, 12) + '...');
               
-              // Try to dial using circuit relay multiaddr
+              // Try to dial using relay circuit multiaddr
               let connected = false;
               for (const addr of peer.multiaddrs) {
                 try {
@@ -306,8 +351,6 @@ export class ByteCaveClient {
               console.debug('[ByteCave] Refresh: Peer already connected:', peer.peerId.slice(0, 12) + '...');
             }
           }
-          
-          break; // Successfully refreshed from one relay
         }
       } catch (err: any) {
         console.warn('[ByteCave] Refresh: Failed to get directory from relay:', err.message);
@@ -330,15 +373,9 @@ export class ByteCaveClient {
       return { success: false, error: 'P2P node not initialized' };
     }
 
-    // Get all connected peers (excluding relay)
+    // Get all connected peers
     const allPeers = this.node.getPeers();
-    const relayPeerIds = new Set(
-      this.config.relayPeers?.map(addr => addr.split('/p2p/').pop()) || []
-    );
-    
-    const connectedPeerIds = allPeers
-      .map(p => p.toString())
-      .filter(peerId => !relayPeerIds.has(peerId));
+    const connectedPeerIds = allPeers.map(p => p.toString());
     
     console.log('[ByteCave] Store - connected storage peers:', connectedPeerIds.length);
     console.log('[ByteCave] Store - knownPeers with registration info:', this.knownPeers.size);
@@ -807,14 +844,14 @@ Nonce: ${nonce}`;
    * Check if a nodeId is registered in the on-chain registry
    */
   private async checkNodeRegistration(nodeId: string): Promise<boolean> {
-    if (!this.discovery) {
+    if (!this.contractDiscovery) {
       // No contract configured - skip registration check
       return true;
     }
     
     try {
-      const registeredNodes = await this.discovery.getActiveNodes();
-      return registeredNodes.some(node => node.nodeId === nodeId);
+      const registeredNodes = await this.contractDiscovery.getActiveNodes();
+      return registeredNodes.some((node: any) => node.nodeId === nodeId);
     } catch (error) {
       console.warn('[ByteCave] Failed to check node registration:', error);
       return false;

package/src/discovery.ts

@@ -1,13 +1,45 @@
 /**
- * Contract-based peer discovery
+ * Peer discovery for ByteCave browser clients
  * 
- * Reads registered nodes from the VaultNodeRegistry smart contract
- * to bootstrap P2P connections without any central server.
+ * Supports two discovery methods:
+ * 1. RelayDiscovery - Fast: Query relay's /peers endpoint for instant peer list
+ * 2. ContractDiscovery - Slow: Read from VaultNodeRegistry smart contract
  */
 
 import { ethers } from 'ethers';
 import type { NodeRegistryEntry } from './types.js';
 
+/**
+ * Relay-based peer discovery (FAST)
+ * Queries the relay's HTTP endpoint for currently connected storage nodes
+ */
+export class RelayDiscovery {
+  private relayHttpUrl: string;
+
+  constructor(relayHttpUrl: string) {
+    this.relayHttpUrl = relayHttpUrl;
+  }
+
+  /**
+   * Get currently connected storage nodes from relay
+   * Returns peer IDs and relay circuit multiaddrs
+   */
+  async getConnectedPeers(): Promise<Array<{ peerId: string; multiaddrs: string[] }>> {
+    try {
+      const response = await fetch(`${this.relayHttpUrl}/peers`);
+      if (!response.ok) {
+        throw new Error(`Relay returned ${response.status}`);
+      }
+      const peers = await response.json();
+      console.log('[RelayDiscovery] Found connected peers:', peers.length);
+      return peers;
+    } catch (error) {
+      console.warn('[RelayDiscovery] Failed to fetch peers from relay:', error);
+      return [];
+    }
+  }
+}
+
 const VAULT_REGISTRY_ABI = [
   'function getActiveNodes() external view returns (bytes32[] memory)',
   'function getNode(bytes32 nodeId) external view returns (tuple(address owner, bytes publicKey, string url, bytes32 metadataHash, uint256 registeredAt, bool active))',

package/src/index.ts

@@ -9,7 +9,7 @@
 export const TEST_EXPORT = "ByteCave Browser Package v1.0.0";
 
 export { ByteCaveClient } from './client.js';
-export { ContractDiscovery } from './discovery.js';
+export { ContractDiscovery, RelayDiscovery } from './discovery.js';
 export { p2pProtocolClient } from './p2p-protocols.js';
 
 // Provider exports

package/src/types.ts

@@ -8,7 +8,7 @@ export interface ByteCaveConfig {
   rpcUrl?: string; // Optional - required if vaultNodeRegistryAddress is provided
   appId: string; // Application identifier for storage authorization
   directNodeAddrs?: string[]; // Direct node multiaddrs for WebRTC connections (no relay)
-  relayPeers?: string[]; // Relay node multiaddrs for circuit relay fallback
+  relayPeers?: string[]; // Relay HTTP URLs (e.g., http://localhost:9090) for peer discovery
   maxPeers?: number;
   connectionTimeout?: number;
 }