@gethashd/bytecave-browser 1.0.19 → 1.0.21

package/dist/{chunk-RR3DUVG7.js → chunk-HKE7DLEO.js}

@@ -5777,47 +5777,16 @@ var P2PProtocolClient = class {
       return null;
     }
   }
-  /**
-   * Wait for a direct (non-relay) connection to a peer
-   * Returns true if direct connection is available, false if timeout
-   */
-  async waitForDirectConnection(peerId, timeoutMs = 3e3) {
-    if (!this.node) return false;
-    const peerIdObj = peerIdFromString(peerId);
-    const startTime = Date.now();
-    while (Date.now() - startTime < timeoutMs) {
-      const connections = this.node.getConnections(peerIdObj);
-      const hasDirectConnection = connections.some((conn) => {
-        const isRelay = conn.remoteAddr.toString().includes("/p2p-circuit");
-        return !isRelay;
-      });
-      if (hasDirectConnection) {
-        console.log("[ByteCave P2P] Direct connection established to", peerId.slice(0, 12));
-        return true;
-      }
-      await new Promise((resolve) => setTimeout(resolve, 100));
-    }
-    console.warn("[ByteCave P2P] Timeout waiting for direct connection to", peerId.slice(0, 12));
-    return false;
-  }
   /**
    * Get health info from a peer via P2P stream
-   * Waits for direct connection upgrade before querying
    */
-  async getHealthFromPeer(peerId, waitForDirect = true) {
+  async getHealthFromPeer(peerId) {
     if (!this.node) {
       console.warn("[ByteCave P2P] No node available for health request");
       return null;
     }
     try {
       const peerIdObj = peerIdFromString(peerId);
-      if (waitForDirect) {
-        const hasDirect = await this.waitForDirectConnection(peerId, 3e3);
-        if (!hasDirect) {
-          console.warn("[ByteCave P2P] No direct connection available for health query to", peerId.slice(0, 12));
-          return null;
-        }
-      }
       const stream = await this.node.dialProtocol(peerIdObj, PROTOCOL_HEALTH);
       await this.writeMessage(stream, {});
       const response = await this.readMessage(stream);
@@ -5985,6 +5954,7 @@ import { floodsub } from "@libp2p/floodsub";
 import { identify } from "@libp2p/identify";
 import { bootstrap } from "@libp2p/bootstrap";
 import { circuitRelayTransport } from "@libp2p/circuit-relay-v2";
+import { dcutr } from "@libp2p/dcutr";
 import { multiaddr } from "@multiformats/multiaddr";
 import { fromString, toString } from "uint8arrays";
 import { ethers as ethers2 } from "ethers";
@@ -6053,7 +6023,8 @@ var ByteCaveClient = class {
         streamMuxers: [yamux()],
         services: {
           identify: identify(),
-          pubsub: floodsub()
+          pubsub: floodsub(),
+          dcutr: dcutr()
         },
         connectionGater: {
           denyDialMultiaddr: () => false,
@@ -6675,12 +6646,7 @@ Nonce: ${nonce}`;
       blobCount: announcement.blobCount,
       timestamp: announcement.timestamp,
       multiaddrs: announcement.multiaddrs,
-      relayAddrs: announcement.relayAddrs || existing?.relayAddrs,
-      // Store on-chain registration status
-      registeredOnChain: announcement.registeredOnChain || false,
-      onChainNodeId: announcement.onChainNodeId || existing?.onChainNodeId,
-      // Store relay flag so we can filter out relays from storage attempts
-      isRelay: announcement.isRelay || false
+      relayAddrs: announcement.relayAddrs || existing?.relayAddrs
     };
     this.knownPeers.set(announcement.peerId, peerInfo);
     this.emit("peerAnnounce", peerInfo);

package/dist/index.cjs

@@ -67,6 +67,7 @@ var import_floodsub = require("@libp2p/floodsub");
 var import_identify = require("@libp2p/identify");
 var import_bootstrap = require("@libp2p/bootstrap");
 var import_circuit_relay_v2 = require("@libp2p/circuit-relay-v2");
+var import_dcutr = require("@libp2p/dcutr");
 var import_multiaddr = require("@multiformats/multiaddr");
 var import_uint8arrays = require("uint8arrays");
 var import_ethers2 = require("ethers");
@@ -5844,47 +5845,16 @@ var P2PProtocolClient = class {
       return null;
     }
   }
-  /**
-   * Wait for a direct (non-relay) connection to a peer
-   * Returns true if direct connection is available, false if timeout
-   */
-  async waitForDirectConnection(peerId, timeoutMs = 3e3) {
-    if (!this.node) return false;
-    const peerIdObj = peerIdFromString(peerId);
-    const startTime = Date.now();
-    while (Date.now() - startTime < timeoutMs) {
-      const connections = this.node.getConnections(peerIdObj);
-      const hasDirectConnection = connections.some((conn) => {
-        const isRelay = conn.remoteAddr.toString().includes("/p2p-circuit");
-        return !isRelay;
-      });
-      if (hasDirectConnection) {
-        console.log("[ByteCave P2P] Direct connection established to", peerId.slice(0, 12));
-        return true;
-      }
-      await new Promise((resolve) => setTimeout(resolve, 100));
-    }
-    console.warn("[ByteCave P2P] Timeout waiting for direct connection to", peerId.slice(0, 12));
-    return false;
-  }
   /**
    * Get health info from a peer via P2P stream
-   * Waits for direct connection upgrade before querying
    */
-  async getHealthFromPeer(peerId, waitForDirect = true) {
+  async getHealthFromPeer(peerId) {
     if (!this.node) {
       console.warn("[ByteCave P2P] No node available for health request");
       return null;
     }
     try {
       const peerIdObj = peerIdFromString(peerId);
-      if (waitForDirect) {
-        const hasDirect = await this.waitForDirectConnection(peerId, 3e3);
-        if (!hasDirect) {
-          console.warn("[ByteCave P2P] No direct connection available for health query to", peerId.slice(0, 12));
-          return null;
-        }
-      }
       const stream = await this.node.dialProtocol(peerIdObj, PROTOCOL_HEALTH);
       await this.writeMessage(stream, {});
       const response = await this.readMessage(stream);
@@ -6106,7 +6076,8 @@ var ByteCaveClient = class {
         streamMuxers: [(0, import_libp2p_yamux.yamux)()],
         services: {
           identify: (0, import_identify.identify)(),
-          pubsub: (0, import_floodsub.floodsub)()
+          pubsub: (0, import_floodsub.floodsub)(),
+          dcutr: (0, import_dcutr.dcutr)()
         },
         connectionGater: {
           denyDialMultiaddr: () => false,
@@ -6728,12 +6699,7 @@ Nonce: ${nonce}`;
       blobCount: announcement.blobCount,
       timestamp: announcement.timestamp,
       multiaddrs: announcement.multiaddrs,
-      relayAddrs: announcement.relayAddrs || existing?.relayAddrs,
-      // Store on-chain registration status
-      registeredOnChain: announcement.registeredOnChain || false,
-      onChainNodeId: announcement.onChainNodeId || existing?.onChainNodeId,
-      // Store relay flag so we can filter out relays from storage attempts
-      isRelay: announcement.isRelay || false
+      relayAddrs: announcement.relayAddrs || existing?.relayAddrs
     };
     this.knownPeers.set(announcement.peerId, peerInfo);
     this.emit("peerAnnounce", peerInfo);

package/dist/index.js

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

package/dist/p2p-protocols.d.ts

@@ -90,16 +90,10 @@ export declare class P2PProtocolClient {
         data: Uint8Array;
         mimeType: string;
     } | null>;
-    /**
-     * Wait for a direct (non-relay) connection to a peer
-     * Returns true if direct connection is available, false if timeout
-     */
-    private waitForDirectConnection;
     /**
      * Get health info from a peer via P2P stream
-     * Waits for direct connection upgrade before querying
      */
-    getHealthFromPeer(peerId: string, waitForDirect?: boolean): Promise<P2PHealthResponse | null>;
+    getHealthFromPeer(peerId: string): Promise<P2PHealthResponse | null>;
     /**
      * Query relay for peer directory
      */

package/dist/react/index.cjs

@@ -402,6 +402,7 @@ var import_floodsub = require("@libp2p/floodsub");
 var import_identify = require("@libp2p/identify");
 var import_bootstrap = require("@libp2p/bootstrap");
 var import_circuit_relay_v2 = require("@libp2p/circuit-relay-v2");
+var import_dcutr = require("@libp2p/dcutr");
 var import_multiaddr = require("@multiformats/multiaddr");
 var import_uint8arrays = require("uint8arrays");
 var import_ethers2 = require("ethers");
@@ -6099,47 +6100,16 @@ var P2PProtocolClient = class {
       return null;
     }
   }
-  /**
-   * Wait for a direct (non-relay) connection to a peer
-   * Returns true if direct connection is available, false if timeout
-   */
-  async waitForDirectConnection(peerId, timeoutMs = 3e3) {
-    if (!this.node) return false;
-    const peerIdObj = peerIdFromString(peerId);
-    const startTime = Date.now();
-    while (Date.now() - startTime < timeoutMs) {
-      const connections = this.node.getConnections(peerIdObj);
-      const hasDirectConnection = connections.some((conn) => {
-        const isRelay = conn.remoteAddr.toString().includes("/p2p-circuit");
-        return !isRelay;
-      });
-      if (hasDirectConnection) {
-        console.log("[ByteCave P2P] Direct connection established to", peerId.slice(0, 12));
-        return true;
-      }
-      await new Promise((resolve) => setTimeout(resolve, 100));
-    }
-    console.warn("[ByteCave P2P] Timeout waiting for direct connection to", peerId.slice(0, 12));
-    return false;
-  }
   /**
    * Get health info from a peer via P2P stream
-   * Waits for direct connection upgrade before querying
    */
-  async getHealthFromPeer(peerId, waitForDirect = true) {
+  async getHealthFromPeer(peerId) {
     if (!this.node) {
       console.warn("[ByteCave P2P] No node available for health request");
       return null;
     }
     try {
       const peerIdObj = peerIdFromString(peerId);
-      if (waitForDirect) {
-        const hasDirect = await this.waitForDirectConnection(peerId, 3e3);
-        if (!hasDirect) {
-          console.warn("[ByteCave P2P] No direct connection available for health query to", peerId.slice(0, 12));
-          return null;
-        }
-      }
       const stream = await this.node.dialProtocol(peerIdObj, PROTOCOL_HEALTH);
       await this.writeMessage(stream, {});
       const response = await this.readMessage(stream);

package/dist/react/index.js

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

package/package.json

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

package/src/client.ts

@@ -13,6 +13,7 @@ import { floodsub } from '@libp2p/floodsub';
 import { identify } from '@libp2p/identify';
 import { bootstrap } from '@libp2p/bootstrap';
 import { circuitRelayTransport } from '@libp2p/circuit-relay-v2';
+import { dcutr } from '@libp2p/dcutr';
 import { multiaddr } from '@multiformats/multiaddr';
 import { peerIdFromString } from '@libp2p/peer-id';
 import { fromString, toString } from 'uint8arrays';
@@ -104,7 +105,8 @@ export class ByteCaveClient {
         streamMuxers: [yamux()],
         services: {
           identify: identify(),
-          pubsub: floodsub()
+          pubsub: floodsub(),
+          dcutr: dcutr() as any
         },
         connectionGater: {
           denyDialMultiaddr: () => false,
@@ -879,12 +881,7 @@ Nonce: ${nonce}`;
       blobCount: announcement.blobCount,
       timestamp: announcement.timestamp,
       multiaddrs: announcement.multiaddrs,
-      relayAddrs: announcement.relayAddrs || (existing as any)?.relayAddrs,
-      // Store on-chain registration status
-      registeredOnChain: announcement.registeredOnChain || false,
-      onChainNodeId: announcement.onChainNodeId || (existing as any)?.onChainNodeId,
-      // Store relay flag so we can filter out relays from storage attempts
-      isRelay: announcement.isRelay || false
+      relayAddrs: announcement.relayAddrs || (existing as any)?.relayAddrs
     };
 
     this.knownPeers.set(announcement.peerId, peerInfo);

package/src/p2p-protocols.ts

@@ -125,7 +125,7 @@ export class P2PProtocolClient {
       // Wrap the entire operation in a timeout
       const storePromise = (async () => {
         console.log('[ByteCave P2P] Step 1: Dialing store protocol...');
-        // Use the store protocol for browser-to-node storage (with authorization)
+        // dialProtocol will upgrade limited relay connections to full connections automatically
         const stream = await this.node!.dialProtocol(peerIdObj, '/bytecave/store/1.0.0');
         console.log('[ByteCave P2P] Step 2: Stream established');
 
@@ -219,59 +219,20 @@ export class P2PProtocolClient {
     }
   }
 
-  /**
-   * Wait for a direct (non-relay) connection to a peer
-   * Returns true if direct connection is available, false if timeout
-   */
-  private async waitForDirectConnection(peerId: string, timeoutMs: number = 3000): Promise<boolean> {
-    if (!this.node) return false;
-    
-    const peerIdObj = peerIdFromString(peerId);
-    const startTime = Date.now();
-    
-    while (Date.now() - startTime < timeoutMs) {
-      const connections = this.node.getConnections(peerIdObj);
-      const hasDirectConnection = connections.some(conn => {
-        // Check if connection is NOT a relay circuit (direct WebRTC or WebSocket)
-        const isRelay = conn.remoteAddr.toString().includes('/p2p-circuit');
-        return !isRelay;
-      });
-      
-      if (hasDirectConnection) {
-        console.log('[ByteCave P2P] Direct connection established to', peerId.slice(0, 12));
-        return true;
-      }
-      
-      // Wait 100ms before checking again
-      await new Promise(resolve => setTimeout(resolve, 100));
-    }
-    
-    console.warn('[ByteCave P2P] Timeout waiting for direct connection to', peerId.slice(0, 12));
-    return false;
-  }
-
   /**
    * Get health info from a peer via P2P stream
-   * Waits for direct connection upgrade before querying
    */
-  async getHealthFromPeer(peerId: string, waitForDirect: boolean = true): Promise<P2PHealthResponse | null> {
+  async getHealthFromPeer(peerId: string): Promise<P2PHealthResponse | null> {
     if (!this.node) {
       console.warn('[ByteCave P2P] No node available for health request');
       return null;
     }
 
     try {
+      
       // Convert string peerId to PeerId object
       const peerIdObj = peerIdFromString(peerId);
       
-      // Wait for DCUtR to upgrade connection to direct WebRTC
-      if (waitForDirect) {
-        const hasDirect = await this.waitForDirectConnection(peerId, 3000);
-        if (!hasDirect) {
-          console.warn('[ByteCave P2P] No direct connection available for health query to', peerId.slice(0, 12));
-          return null;
-        }
-      }
 
       const stream = await this.node.dialProtocol(peerIdObj, PROTOCOL_HEALTH);